zvlex retweeted
Hey everyone, Ruby 4.0.10 is out! It contains a critical security fix. Update immediately! ruby-lang.org/en/news/2026/1…
Fedora 45 Released With Many Leading-Edge Linux Innovations
phoronix.com/news/Fedora-45-…
zvlex retweeted
Ruby’s turn 😅
Remember the GitLab bug? Well now it moved upstream into Ruby.
Multiple 10.0 CRITICAL exploits.
Patch now 🚨
Happy Friday 🤠
ruby-lang.org/en/news/2026/1…
zvlex retweeted
A purported BioWare developer has leaked a trailer for the cancelled ME 5 on Reddit.
The footage, reportedly titled "MASS EFFECT UNIVERSE," appears to suggest the project was further along in development.
Its authenticity remains unverified.
#MassEffect
zvlex retweeted
Лучшее, что я видел за последнее время — чел пилит ASCII MMORPG, в которой вся графика состоит из букв и символов.
Да, буквально весь мир, персонажи, окружение и спецэффекты нарисованы разноцветным текстом.
Автор сейчас экспериментирует с магией, визуалом и боссами. Я прям залип на то, как из нескольких десятков символов получается такая красота.
Буквально сны при температуре 37,2.
Via: tiktok.com/@Ansenjeo
Let's try run Windows XP inside this tweet, tap to open pieter.com/xp/x
zvlex retweeted
ZJIT is now as fast as YJIT railsatscale.com/2026-10-09-…
zvlex retweeted
In programming, "speed" is not so simple to measure. There are a few measures you look at:
Concurrency: The number of things your system can handle at once.
Throughput: The actual number of requests served per second in real world conditions.
Latency: How long it takes for any one request under real world conditions to complete. This includes queueing delay.
Queueing Delay: How long a request has to wait at the front door before your system even starts processing it.
You typically are playing a balancing act between maximizing throughput and minimizing latency on any single server, while increasing number of servers (capacity) to account for actual load.
A system under load does not behave the same as a system with spare capacity. Raw speed doesn't save you under contention, because "just do the thing as fast as it can possibly be done" is just insufficient.
Instead, you have to write your code in such a way that any one given thing can "yield" to other things. If you don't, the requests you're working on finish quickly, but once all of your threads/processes are fully utilized, you have no way to handle more load without introducing queueing (which eventually becomes failures/timeouts) on callers.
This brings us to queueing delay. When the system is processing all of the data that it can, the callers have to all just sit there and either wait, retry or fail. If your system were able to accept more concurrent work, you can lower this queuing delay under heavy load. If you can't do that, you end up trading away too much of your goodput (requests that actually succeed within their deadline) in exchange for consistently low latency for the operations that you do handle.
When building systems at scale, the general guiding light is keeping the queue delay low, and keeping goodput as high as possible.
To do this, you accept as much work as the internal system can track (increasing memory usage typically), allowing latency to go up, in order to accept more concurrent traffic internally. You still need backpressure and load shedding, since no scheduler saves you from arrival rates that permanently exceed what you can serve, but within those bounds you keep goodput maximized.
For this to actually work, your internal schedulers need to be able to do something called "preemption". This is where any given operation cannot take an entire CPU core for longer than some given period of time, or for some amount of operations. A "preemptive scheduler" balances work fairly across all of the operations that are asking for CPU cycles. (Work stealing, where idle cores pull queued work from busy ones, helps too, but plenty of cooperative runtimes have that. Preemption is the key part.)
The BEAM is a powerhouse for this. It preempts processes by counting "reductions," so no process can hog a scheduler. Immutability and share-nothing processes make that preemption cheap and harmless: a process is never paused while holding a lock someone else needs, and every process has its own heap and garbage collector, so there are no global stop-the-world pauses. This allows BEAM applications to achieve maximal goodput, with very low failures due to queue delay, while spreading latency across all work fairly.
Without that preemption, you would see a huge spread among the latency of your system. i.e some requests happening practically immediately, while other requests take pathologically large amounts of time to complete.
I get that people want programming language not to matter these days, but at a very minimum you cannot escape the limitations of your runtime. The BEAM's runtime is built for operating at scale, and will always be smoked on benchmarks for tight loop operations where there is no resource contention.
#ElixirLang
zvlex retweeted
I took a stab at improving the performance of Elixir. I used the PR for Elixir that @ZachSDaniel1 posted and worked some more on it. In the benchmark Elixir is now faster than Rust (ccece30 newest commit) for the Sidebar and Search benchmark.
Last conversion of the Campfire from my token stash goes to JavaScript/Express. As with the others, I'm sure you can find more to optimize. But this gives you a sense of what order of magnitude these options exist within with agent-led development. github.com/basecamp/once-cam…
zvlex retweeted
I have a branch with various performance improvements to the Elixir version, focused on specifically the websocket side of things. I didn't spend much time on the rest.
The load generation code was flawed in overload scenarios because any socket that had an issue just stayed disconnected forever, so I assume no benchmarks were run in this fashion prior. Now those reconnect on disconnect and continue sending traffic (a more realistic scenario).
Most relevant finding:
In an overload situation, the rust implementation delivers a whopping 1% of messages to all connected clients, and the Elixir implementation delivers 100% of messages to all clients, applying natural backpressure to writes.
Speed is cool. Rust is fast. Speed is not even close to the most important thing when building real applications.
I've had agents implement and optimize the Campfire web app in Elixir, Go, and Rust. Yes, Ruby is the slowest. I didn't care about that when the pay-off was huge in terms of productivity and developer joy. But if you're no longer reading the code? github.com/basecamp/once-cam…
Readers added context they thought people might want to know
The shown benchmarks use non-equivalent implementations: Elixir routes all DB queries through a single GenServer with Redis for jobs (retained from Rails), while Rust uses in-process queues, omits CSRF tags/fields, and applies other caching changes.
github.com/basecamp/once-…
raw.githubusercontent.com/basecamp/once-…
github.com/basecamp/once-…
github.com/basecamp/once-…
x.com/zachsdaniel1/s…
zvlex retweeted
I still own israilsdead.com and was worried for a second I'd have to update it this week.
zvlex retweeted
Clearly, this @DHH Rails World 2026 keynote has become an instant classic. youtube.com/watch?v=V9SxpJpH…
Highlights:
- WebApps are dead since it is so cheap, easy, and fast to build native apps with agentic coding.
- No need for a framework like Ruby on Rails if you can achieve the same functionality with e.g. Rust on the backend while saving a lot of money by reducing the number of needed servers and having a faster application.
- Your application needs a CLI. Because agents love command-line tools.
zvlex retweeted
Emacs 31.1 is out. Here's my usual annotated post on what is new in 31.1
masteringemacs.org/article/w…
zvlex retweeted
Elixir v1.20 released! Now officially a gradually typed language: Elixir type checks every single line of code, finding bugs and dead code, without developer overhead (no typing signatures) and extremely low false positives rate. Plus a faster compiler! Links and reports below.
zvlex retweeted
Our biggest breakthrough in efficiency yet, the Framework Laptop 13 Pro with 20 hours of battery life. In Graphite.
Linux-first with options for Ubuntu pre-installed. Featuring Intel® Core™ Ultra Series 3 processors, LPCAMM2 Memory, a new haptic touchpad, and a touchscreen display.
Pre-orders for the Framework Laptop 13 Pro open now: frame.work



























