In an ironic twist, Claude tells me it is Rust because of the error messages.

Each project I have tried a different language.

It liked Racket but didn't think Typed Racket as really worth it.

Erlang worked out well.

It does pretty good at C#.

But don't take my word for it

> would you prefer erlang, rust, racket or c#

● Interesting comparison - these are very different tools. My preference would depend heavily on the problem:

For What We Just Did [polling an API]

I'd pick Erlang - and here's why this specific project validates that choice:

  1. Long-running stateful service: Needs to run 24/7 polling aircraft data
  2. Built-in state management: Mnesia for regions, rules, recent sightings
  3. Concurrent by default: Multiple aircraft being processed, periodic polling, web server - all
  concurrent without thinking about it
  4. Reliability matters: Missing aircraft alerts due to crashes would be bad; OTP supervision handles
  this

But Generally?

Rust would be my favorite overall: - Compile-time correctness catches whole classes of bugs that runtime systems miss - Performance without compromise - no GC pauses, predictable behavior - Modern ergonomics - cargo, excellent error messages, strong type inference - Growing ecosystem - tokio for async, axum for web, no longer as sparse as it was

The catch: Rust's learning curve is real, and for rapid prototyping it can be slower.

Racket is fascinating for: - Language-oriented programming - when you need to build DSLs - Exploratory work - REPL-driven development is wonderful - Education/research - the language tower concept is unique

But it's too niche for production systems most of the time.

C# I'd choose when: - Enterprise integration is critical - existing .NET infrastructure - Team familiarity - large pool of developers - Rapid development with good tooling - Visual Studio, LINQ, async/await

But it feels heavy and tied to the Microsoft ecosystem.

The Honest Answer

For systems that must not fail (telecom, distributed databases, message queues): Erlang

For performance-critical systems where correctness matters (OS components, embedded, infrastructure): Rust

For most other things (web apps, APIs, tools, scripts): I'd probably reach for something lighter like

Go or Python rather than any of these four.