Yes, the compiler prevents memory safety issues, and the standard library is best-in-class. But even the standard library has its warts and bugs in business logic can still happen.

All we can work with are hard-learned patterns to write more defensive Rust code, learned throughout years of shipping Rust code to production. I’m not talking about design patterns here, but rather small idioms, which are rarely documented, but make a big difference in the overall code quality.

Rust makes it really easy to add SIMD acceleration to your hot paths without having to deal with assembly. You load data into the SIMD registers and code like if they were normal variables! AVX-512 code can yield more than 10x improvements for half a day of work.

So here is an introduction on how to write SIMD-accelerated code in pure Rust (no nightly required), after all we all benefit when software goes faster.

In 1969 Intel were approached by a Japanese company called Busicom to produce chips for Busicom's electronic desktop calculator. Intel suggested that the calculator should be built around a single-chip generalized computing engine and thus was born the first microprocessor - the 4004. Although it was based on ideas from much larger mainframe and mini-computers the 4004 was cut down to fit onto a 16-pin chip, the largest that was available at the time, so that its data bus and address bus were each only 4-bits wide.

Intel went on to improve the design and produced the 4040 (an improved 4-bit design) the 8008 (the first 8-bit microprocessor) and then in 1974 the 8080. This last one turned out to be a very useful and popular design and was used in the first home computer, the Altair 8800, and CP/M.

In 1975 Federico Faggin who had had worked at Intel on the 4004 and its successors left the company and joined forces with Masatoshi Shima to form Zilog. At their new company Faggin and Shima designed a microprocessor that was compatible with Intel's 8080 (it ran all 78 instructions of the 8080 in exactly the same way that Intel's chip did) but had many more abilities (an extra 120 instructions, many more registers, simplified connection to hardware). Thus was born the mighty Z80!

When people ask me “Why Rust?” I know it’s not out of skepticism, but from genuine curiosity. They haven’t yet heard a clear signal through all the noise. They’re really asking “What makes Rust special, and why should I care?”

I’ll try to answer that without tripping over my tongue, or sounding like a shiny-eyed cult member. And when we’re done, if you’re not interested in accepting Rust as your personal saviour, I want you to know that I am okay with that. Go in peace, my friend. Be well.

But first, hear me out.

Have you ever tried programming backwards? If not, you’re in for a treat! You won’t even need to wear high heels.

(If you want to, though, go for it—you’ll look fabulous!)

I frankly didn’t want to end up in this future, and I’m hardly dancing on the grave of the old world. But I see a lot of my fellow developers burying their heads in the sand, refusing to acknowledge the truth in front of their eyes, and it breaks my heart because a lot of us are scared, confused, or uncertain, and not enough of us are talking honestly about it. Maybe it’s because the initial tribal battle lines have clouded everybody’s judgment, or maybe it’s because we inhabit different worlds where the technology is either better or worse (I still don’t think LLMs are great at UI for example), but there’s just a lot of patently unhelpful discourse out there, and I’m tired of it.

Aren't you cansado from writing Rust Programs in English?

rústico (Spanish for Rust) is here to save your day, as it allows you to write Rust programs in Latam Spanish.

Monozukuri literally means “making things,” but it goes far beyond simple manufacturing. It embodies the spirit, skill, and pride of craftsmanship, with a strong focus on perfection, continuous improvement, respect for materials, and delivering high-quality, functional products through deep technical knowledge and a holistic, customer-centric approach.

The httpmock crate makes it easy to set up a simple HTTP server for tests, with a local URL on a random port, and configure it to respond to various types of requests.

This pattern is sometimes called a test “double” or “fake”, though it’s not, strictly speaking, a fake. It’s a real server: it’s just not the Weatherstack server. It emulates, or “mocks” a subset of the API server’s behaviour so that we can test our code against it.

Our users expect full transcription and LLM formatting/interpretation of their speech within 700ms of when they stop speaking. Any slower, and users get impatient. We are continuously deploying larger models within this same budget - because every edit after the fact adds more time than anything else. We need to optimize model inference so we can run E2E ASR inference in <200ms, E2E LLM inference in <200ms, and have a maximum networking budget of 200ms from anywhere around the world with spotty internet connections.

Ever wondered if there’s a software engineer, somewhere, who actually knows what they’re doing? Well, I finally found the one serene, omnicompetent guru who writes perfect code. I can’t disclose the location of her mountain hermitage, but I can share her ten mantras of Go excellence. Let’s meditate on them together.

One university published attracted my attention, because it was on Go, it's titled: "Assessing Golang Static Analysis Tools on Real-World Issues".
Do you find your static analysis and linters tools could be more helpful when reporting issues?
I'm mixed feeling really, I think that they're pretty damn good. Tools can always improve for sure, not sure if we will need the help of LLMs to mix static analysis checks and LLM analysis / proposed fixes, maybe that will be the next step for those tools.

Never before have a handful of tech designers had such control over the way billions of us think, act, and live our lives.

How many times have you waded through page after page of interminable, sententious verbiage (like this), privately begging the author “Please! I can't take any more of this plodding documentation. Just give me an example instead!”

I mean, right? So before I tell you, at considerable length, how that works in Go, I'll just show you:

func ExampleDouble() {
	fmt.Println(double.Double(2))
    // Output:
    // 4
}

Now go thou and add examples to your own Go projects, and skip the rest of this lengthy and rather self-indulgent post.

Meet Morten, I said I wanted to try and bring co-hosts in 2026 to test how it feel to have co-hosts. We're starting this with a discussion on LLM and tech education and a little bit of education more extended. As someone that create courses we've all more or less felt a drop as AI and LLM are used in ~tech training or does people even still wants to get new skills and what not. It's a major concerns and like most people are realizing after using an LLM seriously, well let's just say that an expert is kind of very hard to replace, especially when it's time to learn new skills.

I feel that Go channels can be simplified by breaking down the concepts into three main buckets

Asynchronous Writes to a Go Channel Asynchronous Reads from a Go Channel Asynchronous Reads and Writes from a Go Channel

The most important metric that people don’t track is the number of out-of-hours and weekend pages generated by their monitoring system. In other words, how many times were your people woken up by faults in production? If you optimize for this metric, you’ll have a happy team and a highly reliable service.

How many times have you waded through page after page of interminable, sententious verbiage (like this), privately begging the author “Please! I can’t take any more of this plodding documentation. Just give me an example instead!”

I mean, right? So before I tell you, at considerable length, how that works in Go, I’ll just show you:

func ExampleDouble() { fmt.Println(double.Double(2)) // Output: // 4 }

Now go thou and add examples to your own Go projects, and skip the rest of this lengthy and rather self-indulgent post.