#Concurrency
23 notas · última:
Leverage Concurrency Efficiently When Managing Multiple Tasks in Elixir
Builds from Task.start and Task.async to Task.async_stream, showing why one process per item breaks at scale and how max_concurrency, ordering, and timeouts trade off against each other.
Building High-Performance .NET Apps With C# Channels
A practical rundown of bounded vs. unbounded C# Channels, a bounded-channel background processor, and a write-back caching pattern for a shopping cart.
The Publish Pattern
A concurrency pattern for decoupling producers and consumers using a const shared_ptr, avoiding mutex bottlenecks while keeping the consumer always on the latest published version.
Beyond Functional Programming with Elixir and Erlang
José Valim argues that functional programming was never the goal of the Erlang VM, only the means to fault-tolerant, concurrent, maintainable distributed systems.
Elixir
Elixir is a functional, concurrent language created by José Valim that runs on the BEAM virtual machine. It builds on Erlang's strengths — fault-tolerance, distribution, the actor model — while…
OTP (Open Telecom Platform)
OTP is a collection of middleware, libraries, and design principles for building applications in Erlang. The name stands for Open Telecom Platform — a branding attempt from Ericsson — but neither…
Erlang
Erlang is a concurrent, functional programming language created by Joe Armstrong, Robert Virding, and Mike Williams at Ericsson in 1986 to improve the development of telephony applications. It was…
Don’t Ignore Thread Safety — Design for Concurrency from Day One
The article argues that thread safety should be built into software design from the start because concurrency bugs are hard to reproduce, appear under load, and can be reduced with safer patterns and automated review.
Things Elixir's Phoenix Framework Does Right
The article argues that Phoenix sits near the middle between flexible and strict frameworks, stands out in persistent communication, benefits from BEAM-based concurrency, and handles failures and clusters with built-in supervision.
Concurrency basics
The page says a server has state, uses a main loop, and can handle synchronous or asynchronous requests, so concurrency should be treated as a generic property of server behavior.
My reasons to love F#
The page lists reasons to like F#: cross-platform open source support, interactive exploratory work, functional style, immutability, clarity, prototyping, productivity, distribution, concurrency, syntax, community, and learning resources.
Writing Concurrent Programs Using F# Mailbox Processors
The article explains F# mailbox processors through the actor model, then shows basic posting, replies, scanning, and a coordinator-worker setup that measures workload and charts per-agent results.
Elixir Flow-Based Programming
The author explores implementing flow-based programming in Elixir by using GenServer and Erlang digraphs, then adds initial values, component ports, and multiple processes per component to exploit concurrency.
Implementando “Actor Model” com Akka.net – Parte 2 – Um exemplo muito simples
Mostra um exemplo mínimo de Akka.net com um chat de console entre UserInterfaceActor e SimpleBotActor, explicando o bootstrapping, o envio de mensagens e o uso de Sender.
Why I’m betting on Elixir
The author argues that Elixir and Phoenix keep Ruby on Rails’ focus on developer happiness while adding fault tolerance, concurrency, speed, and a strong ecosystem backed by Erlang.
An intro to OTP in Elixir
The post explains OTP as Erlang’s development environment for concurrent programming, then builds a FizzBuzz server with GenServer, client APIs, callbacks, caching, and process-based I/O.
How to Convince Your Company to Go With Golang
SendGrid explains why it moved its backend development to Go, arguing that concurrency needs, developer interest, maintenance costs, and community building outweighed Java, Scala, and library-support drawbacks.
Learn elixir in Y Minutes
The page introduces Elixir as a functional language on the Erlang VM and walks through its core syntax, pattern matching, control flow, modules, structs, exceptions, and message-based concurrency.
Ruby Concurrency and Parallelism: A Practical Primer
The article explains the difference between concurrency and parallelism in Ruby and compares forking, threading, thread pools, and background jobs, with performance and resource tradeoffs.
Elixir - The Love Child of Ruby and Erlang
The article tours Elixir’s core features: the IEx shell, functional tools, immutability, recursion, streams, the pipe operator, processes, message passing, and Erlang interoperability.
Why Dart is not the language of the future
Rafaël Garcia-Suarez argues that Dart combines weak static checking, awkward typing, and heavy isolates without gaining the flexibility of dynamic languages, so it looks like a step backward.
Rumors of Ruby’s Demise
The post argues that Ruby is still a strong choice because developer joy and productivity matter, and that concurrency hype often reflects problems faced by only a small slice of teams.
Ruby concurrency explained
The article explains concurrency in Ruby through threads, multiple processes, fibers, and non-blocking I/O, and argues that each approach trades simplicity, safety, memory use, and throughput.