Atlas · Languages · 29 entries
Languages
Twenty years of arguments about programming languages — language design, type systems, dynamic vs. static, OO and its discontents, and the perennial question of which language to pick and why. A handful still get assigned in undergrad CS classes; a few others ended up shaping how major companies write code. Author's notes are coming.
- ★ Essentials
- 👍 Good read
- 💩 Not worth it
- 🤓 Language nerd
- 😄 Humor
- 📚 Story / fiction
- 🕹️ Gaming
- 🔮 Called it
- 🤡 Whiffed it
-
2017
Why Kotlin Is Better Than Whatever Dumb Language You're Using
Steve set out to port his game Wyvern to Android, hit Android's notoriously bad APIs, nearly quit, and was rescued by a new JVM language from JetBrains. The essay is the conversion story: why Kotlin, built IDE-first and "just butter," won him over when fifty other languages hadn't — and why he, a self-described blue-collar working programmer, wants street food, not the truffled snails of Scala and Clojure.
-
2010
Haskell Researchers Announce Discovery of Industry Programmer Who Gives a Shit
The conceit runs on arithmetic. Every Haskell post on reddit gets exactly 38 upvotes from a 37-person mailing list — so there must be precisely one lurker, and the community sets out to find him — only to learn his devotion is strictly theoretical. A gentle, affectionate skewering of a language famous for being brilliant and unused.
-
2010
WikiLeaks to Leak 5000 Open Source Java Projects With All That Private/Final Bullshit Removed
Filed deadpan from Iceland, the report announces that WikiLeaks will re-release thousands of open-source Java projects with all access modifiers made public and every deprecation tag removed. The target is the Java habit of treating private as a sacred right — the developer who insists you may never open a door in your own house, even in an emergency, even decades after they are gone. The healthier alternative, voiced at the end: we're all adults here.
-
2008
Ejacs: a JavaScript interpreter for Emacs
Steve open-sources Ejacs — a full ECMAScript interpreter written entirely in Emacs Lisp, around the Narcissus interpreter he ported for js2-mode. The post is half release-notes and half a long, rambling, very Steve apology for having broken his thumbnail and not blogged in months.
-
2008
The Universal Design Pattern
The humble name/value pair — written off everywhere as a cheap hack — argued out as the best known way to build software that can grow and last. Steve calls it the Universal Design Pattern, and leans on Hofstadter to earn the name.
-
2008
Rhinos and Tigers
Steve's I/O talk had the deliberately-boring title "Server-Side JavaScript on the Java Virtual Machine" and ended standing-room only, in a 400-person room he had to rename Rhinos and Tigers halfway through. The middle section, "Static Typing's Paper Tigers," is the part the industry still quotes — Steve's argument that the threats static-typing advocates warn dynamic-language users about are mostly folded out of paper.
-
2008
Dynamic Languages Strike Back
Steve's case that the two standard knocks on dynamic languages — they are slow, and their tooling is bad — are not intrinsic, and are about to be demolished by runtime techniques: polymorphic inline caches, type feedback, and the then-new trace trees. Along the way he argues static type systems have hit their theoretical ceiling, and that language popularity has frozen for a decade. He transcribed the hour-long talk himself.
-
2008
Emergency Elisp
An Emacs Lisp cookbook for the C / Java / JavaScript programmer. Skips the usual Lisp evangelism and walks straight through the lexical tokens, the operators, and the constructs you already know — translated into parenthesized form.
-
2007
The Next Big Language
Languages go through long periods of initial obscurity, then long periods of semi-obscurity, then total obscurity. The few that break out share a short list of characteristics. Steve walks through the list, then walks through the candidates of 2007 to see which ones had what it took.
-
2006
Parabola
An airport security guard called T.S. — Type Safety, of course — stands at the head of a slow-moving caterpillar of a queue, enforcing every written and unwritten rule. A dark-haired woman named Anushri rushes up with a handwritten note: her husband is in the E.R., the Red Cross has put her on the next flight, the gate closes in ten minutes. The crowd of programmers in line begins, helpfully, to suggest workarounds: a debugger on his back port, a reboot, reflection, unit tests — every programmer's instinct for hacking around an interface that was never built to make an exception.
-
2006
Lisp is Not an Acceptable Lisp
The Road to Lisp ends at a perfectly elegant outpost — and then turns into the same dirt road the rest of us slog through, hacking around the outpost's inadequacies. Steve's case is that no Lisp programmer is using only Lisp, and the cult will not let anyone say so out loud.
-
2006
Execution in the Kingdom of Nouns
A 2006 essay disguised as a fairy tale. In the Kingdom of Javaland, verbs are slaves — every action must be wrapped in a noun, a Manager or a Factory or an Executor, before it is allowed out in public. Steve tells the story deadpan, and the joke became the standard critique of object-oriented overreach.
-
2005
Digging Into Ruby Symbols
The community had settled on "use a symbol whenever you mean a name." Steve agrees, and then keeps going: Ruby's symbols are the visible tip of a feature that isn't there yet. In Lisp the template you hand to eval is a data structure, not a string — you can read it, walk it, modify it, and the debugger can step through it. In Ruby it's Pinocchio in a heredoc, and class_eval is the Good Fairy who takes it away into a black box.
-
2005
Is Weak Typing Strong Enough?
Steve lays out the five honest advantages of static typing and the six honest disadvantages, then brings in evidence most language essays never have: a multi-year period in which the same group at Amazon ran Perl and Java side by side on the same kinds of tasks, with the same engineers rotating between. The Perl code stayed smaller, simpler, and shipped faster; the data integrity problems were manageable; the static-typing team eventually started cutting holes in their own type system to survive change. The conclusion is careful: not "dynamic always wins," but "Lisp's selective-typing model is the close-to-ideal shape."
-
2005
The Next Big Thing
Steve is watching Java 5 land and seeing the 1995 sweet spot (expressive enough, simple enough, fast enough) slip out of reach. Generics add complexity without runtime payoff. Enums are an even bigger pile of crap. The "smart for-loop" is a band-aid over the missing first-class function. He pulls back, asks what actually drives language revolutions — pain relief plus a beautiful alternative, on roughly a decade — and names Ruby as the next big thing. Not Lisp, not Haskell, not OCaml. Ruby, because it's nice to look at, and aesthetics matter even in code.
-
2005
Allocation Styles
Steve names six styles — allocation-free, buffer-oriented, collection-oriented, list-oriented, query-oriented, pattern-match — and pairs each with the languages where it is the path of least resistance. The thesis is that programmers inherit the style their first language taught them, mistake it for good engineering, and spend years cutting against the grain of whatever they are actually paid to write. The essay's prescription is to climb as high as the problem will let you and let the profiler tell you when to step back down.
-
2005
Language Grubbing
After a year of "grubbing around" twenty languages, Steve assembles the lessons. Why languages come in waves and form religious camps; why marketing matters more than merit; why C remains essential and C++ remains a problem. Capsule notes on Java's superlinear growth, Perl's surprisingly-quick fade, Python's compactness, Ruby's quiet excellence, Common Lisp's ugliness-around-beauty, ML's speed underneath its strict type system, Haskell's still-distant promise. Punchline: languages DO matter.
-
2005
Scheming Is Believing
Steve had spent more than a decade brushing off Lisp the way most working programmers do — odd syntax, no jobs, a kind of indoor sport for graduate students. Then it snuck up on him. The essay is the account of what he found: not a more expressive language but a more extensible one, where macros and reader macros and a working metaprogramming layer let you reshape the language to fit the problem, rather than the other way around. Adaptability beats expressiveness beats performance. He compares languages to an equalizer of conflicting sliders, and notes — wryly — that Lisp moves the slider you didn't know was there.
-
2005
Choosing Languages
Steve walks past the "Mike calls me OCaml boy" rumours to make a practical case: every language goes into one of four buckets (Production, Scripting, Studyable, Stuck-with), and the right pick is almost always the highest-level option in the right bucket. With a detour through pattern-matching as a Design Pattern in its own right, and Steve's then-current picks: Java for big systems, Ruby for everything else.
-
2005
The Numbers Mini-Language
Steve walks through how six different languages let you write numeric literals: scientific notation, underscores, hex, binary, complex numbers, bignums. The variation is wider than most working programmers realise; Perl's underscore rules are deliberately perverse, Java doesn't even let you write a binary literal, and Emacs Calc's radix notation gets it cleanest. Then the survey turns into a warning: a language that defaults to fixed-precision integers and makes bignums painful to use is encouraging programmers to flirt with disaster, and that's where the integer-overflow bugs and security holes come from.
-
2004
Ancient Languages: Perl
Larry Wall got two enormous things right — embracing Unix and elevating the String to a first-class citizen — and then made one mistake the language could not afford: flattening lists by default. Everything else follows. References-as-pointers, contexts that make every operator unreadable, marketing-as-spec. Steve writes the obituary the way he writes most obituaries: respectfully, then with a long appendix of receipts.
-
2004
A Quick Tour of Ruby
A guided walk through the bits of Ruby that won Steve over: the interactive shell that actually quits when you type "quit", the collection methods that return collections, the functional style that comes for free, the metaobject protocol that lets you patch
Stringat will. With side-by-side dictionary-words examples versus Java and a long detour through why side-effect-free collection operations are worth their cost. -
2004
Language Trickery and EJB
Steve imagines a Java with no for-loop — just a LoopObject class you have to configure, with starting values and increments and a callback. Then comes the turn: the for-loop is a service Java renders to you, the programmer, exactly the way an EJB renders services to its callers, only with syntax that forces the API to be used correctly. From there he walks the slippery slope. Closures. Macros. Erlang. Why are Java programmers, who will read 800-page J2EE manuals, terrified of the word "map"?
-
2004
Tour de Babel
A 2004 languages tour from the Drunken Blog Rants era: C, C++, Lisp, Java, Perl, Ruby and Python, each handed a verdict in Steve's voice. Profane and quietly serious — and underneath the scorecard, an argument about what a language does to the people who think in it.
-
2004
Lisp Wins (I think)
The compressibility problem in Java, illustrated with Perl, Ruby, Python and Java-5 versions of the same five-line program. The metaprogramming gap. Why C++ templates, AspectJ, and operator overloading are partial answers. Why a real macro system is the feature Steve cannot give up. Closes with the caveat that wins as a platform may still belong to Java.
-
2004
When Polymorphism Fails
The classic textbook line ("if you use
instanceofyou threaten little children with switch statements") is true most of the time. Steve's piece is about the exception: extensible systems where the dispatching behavior belongs to the observer, not the observee — illustrated by the perfect OpinionatedElf, an in-game creature whose entire purpose is to announce which other monsters it hates. A virtualdoesElfLikeMe()on every monster class is obviously absurd. The runtime check is the right tool. Steve walks the implications all the way through to a thesis: type is best represented by properties rather than classes. -
2004
Waste Management
Triggered by two phone screens in a row where candidates told Steve cheerfully that C# means "you don't have to worry about memory," the essay makes two points. First: good garbage collectors are quietly getting better than hand-managed memory, just as compilers long ago started producing better assembly than humans. Second: GC does not excuse you from thinking about memory. The four classic traps — over-allocating, hard references to unused objects (the cache pattern), unreleased non-memory resources, and untuned collectors — are the part of the essay working programmers still quote.
-
2004
More OCaml
More on OCaml's reach: perl4caml lets you call any CPAN module from OCaml; mod_ocaml runs it under Apache; the Emacs mode is excellent; the native compiler is competitive; the interactive interpreter is real. And there is a replay debugger that runs in reverse. The small user community, Steve argues, is what you get when a single group of 10x-productive programmers is enough to build everything else you need.
-
2004
OCaml
A note on ML-family type systems and what they let the compiler deduce: stack-allocating heap objects, eliminating virtual calls, exploiting immutability. With a brief tour of why OCaml, mid-2004, looked like a serious candidate for Steve's then-active hunt for a replacement for Java — and a footnote, added in 2005, admitting he drifted back to Lisp.
