Because It's Not Fun Enough: why languages fail | Hacker News Reader

Because It's Not Fun Enough: why languages fail

bytecode.news

94 pointsjottinger128 comments

There's more to a language than the syntax. The libraries, tools, and the ecosystem of developers, documentation, support, etc. are much more important. There are quite a few academic languages that are interesting to people that never really gain much traction because the people behind them just never commit to proper ecosystem building.

Switching languages is a big time commitment. Or at least it used to be. I find myself more open to that now that I can hit the ground running with AI coding tools in most languages. But still, it's a time investment to learn a language, its idioms, its way of doing things, all the tools, libraries, and frameworks, etc. It's not something you do an in afternoon. And certainly not mid project.

The languages that people gravitate to are the ones that look like they are safe, future proof bets. If you are going to spend all this energy learning one, you want to know it's a good investment. Successful languages have lots of users, decent tools, good libraries, etc. Or at least they look like there are serious people behind them. Many people make these bets early in their careers and then stick to them as well. I meet a fair share of people my age that are still sticking to Java. Because that's what they learned when they were in their twenties. I'm 51 now.

Rust is a good example of a language that's hard to learn but managed to get off the ground because of the solid people behind it. It wasn't just an academic exercise: Mozilla was trying to solve a real problem and they managed to get a nice community behind the language and it grew from there. This is not something that happens a lot. People create new languages all the time. But many stay very niche and the projects around them tend to go stale very quickly if they fail to attract a community of users.

I'd argue Rust is one of the most "unfun" languages in terms of syntax but it's offset by the crates ecosystem and cargo toolchain being easily the most pleasant within systems programming

No matter if C or C++ was more "fun", CMake is not and I think the the "fun" parts of coding are worse with Rust but the particularly unpleasant ones are relatively good. In that sense Rust's success might be due to it being more or a "pain pill" than a "vitamin"

Michael Hashimoto has made comments to the effect that Zig is attractive to him relative to Rust simply because it's more enjoyable to write but I think there's very few people for whom that could outweigh the lack of ecosystem

I'm fluent in Rust and I find it quite enjoyable to read and write, more so than almost any other language I know. But, that's a subjective opinion, I wouldn't expect others to feel the same.

Rust probably has more to learn and is indeed probably _more difficult to learn_ than Zig in that it's simply a bigger language (which is quantifiable, even if only approximately) but difficultly of learning vs. enjoyment of reading/writing/speaking are different questions.

It's a bit like saying German is unfun to read and write. To who? To Germans?

Agreed, rust is SUPER not fun IMHO but I use it a lot via FFI for things I wouldn't do in Elixir which I prefer to write/read. The broad array of well built tools on cargo is just so hard to compete with, and cargo as a tool beats any language tooling for any language with similar breadth. The JVM has every tool imaginable but I'd rather built it myself than tangle with JVM tooling.

I liked perl, and later python.

Python was harder to write - it was less expressive to me than perl, which could say stuff like "unless <bleh>" while python would require "if not <bleh>"

it was more regular, more compact and was visually easier to read

but it was the python standard library that kept me going back, because I could solve lots of problems without reinventing the wheel, or becoming a sysadmin to install a package my lowly script required.

Even if you only consider the language itself, semantics, especially the type system, are more important than syntax.

Many people don't really understand the languages they learn until well after they are done mastering them. And some never really pick the deep detail there is to semantics and type theory.

If it is done right, the language might feel nice to use or elegant but users might not articulate why that is. That can be a key selling point. And of course there are a lot of languages where the type system was a bit of an afterthought that got popular anyway. Javascript and other dynamically typed languages comes to mind. Rust kind of sits on the other end of the spectrum. And it has a deserved reputation for being a bit hard to learn because of it.

Arguable. Both are really important. We all know the most run-down-looking restaurants have the best food, but we still go to the ones that look clean and tidy anyway.

The ecosystem makes it feasible to use the language or not. For my personal projects, I won't use a language that doesn't provide some kind of straightforward cross-platform GUI toolkit (nearly) out of the box—which narrows the field enormously.

But it's the syntax and semantics what determine whether I'd want to use the language to begin with, and how maintainable the resulting code is.

I was hoping it would address Lisp.

Lisp is fun. The interactivity and instant turnaround of a Lisp REPL is still rarely matched in other languages. Common Lisp also solved a significant issue other languages didn't address well until much later: the ability to write high-level code that was fast on cheap hardware around the turn of the millennium.

Lisp didn't get popular around the turn of the millennium. Success stories like Naughty Dog, ITA, and Viaweb were rare, and the dominant languages seemed to be Java and various scripting languages starting with the letter P.

Personally I think expressivity and type system power are what make a language "fun". If languages were video games, the Lisp family and Lean4 feel much more like an open-world game with many ways to play it like Factorio or Minecraft.

At the other end, Go would perhaps be the equivalent of an on-rails shooter.

And it honestly makes me disagree with the thesis here because "boring" unexpressive languages have arguably outperformed in terms of adoption for loadbearing software

I really enjoy writing lisp but the ecosystem of libraries is a barren wasteland.

Try to find a TLS library for Common Lisp that doesn't rely on openssl, for example. Last time I looked the most mature library was marked 'experimental'.

This is the double edged sword of particularly extensible customizable languages is that they invariably won't produce a robust ecosystem of packages that can compose with each other in the manner of pip/npm/crates

Hah! SO MANY LANGUAGES got skipped, even from my own CV. I wanted to address Louis/II, for goodness' sake, but it's a CODASYL tool, and not a lot of people remember CODASYL from experience. (Nor should they: I liked it, but... nah, RDMS won for good reasons.)

Lisp is certainly fun, and it lives today and is influential today in multiple environments; I have a Clojure app I work on for my own amusement. And it does have commercial appeal, but it's limited; the three axis thing applies.

I often hear about lisp but never actually figured out what tooling you need Is it interpreted or compiled language? Why should I use it instead of any other languages?

"Lisp" refers to several different languages in the same family, which contributes to the confusion.

Perhaps the default choice is Common Lisp which itself is specified in an ANSI standard and has several competing implementations. Some are compiled, some are interpreted.

Arguably the best is SBCL, which has a mature compiler and garbage collection. If you lean on implementation-specific features you can produce extremely fast code that approaches the performance of C in some benchmarks, but idiomatic and portable lisp is slower in practice.

>Why should I use it instead of any other languages?

The killer feature used to be the REPL. You can write the application function by function, and test the functions, data structures, or classes you write in the REPL as you're actively building the app.

Nowadays with LLMs writing all the code, I honestly don't see much reason to reach for lisp. Agents don't require a REPL, and other languages have vastly superior library support.

> The killer feature used to be the REPL.

The killer (hah!) feature is arguably its homoiconicity, allowing to modify the language easily within itself ("macros"). This has the obvious advantage that you can add missing features (usually) easily yourself; and exactly that causes headaches for those tasked with maintaining other people's code.

> Nowadays with LLMs writing all the code

Oh, you came all the way from the future and that's what you bring us?

I never said I liked the future, but it is what it is.

If you're building products without LLMs today you're going to get outcompeted by people who do, and can iterate faster. I have written a fair bit of lisp and when it isn't refusing to fix security bugs because openai are cowards, 5.6-Sol can do in hours what would take me days.

> You can write the application function by function ...

and then use JUnit or TestNG in Java, or similar features in other languages. Which you can automatically run, including showing code coverage, both with a button in your IDE and as part of the CI/CD process when you commit.

Unit testing doesn't provide the level of interactivity a REPL does. A REPL lets you see the output of parts of an unfinished function based on the running program's state.

If you've already thought out the whole program before you start writing it, that may not be as valuable. In my experience, software often isn't that way and the ease of exploration a REPL and long-running process provide are unmatched.

yes and no. You are correct the REPL provides more interactivity. However the downside is you can break something that used to work while make something else work.

There is no reason you can have a REPL and unit tests in the same. Every change results in running all the tests. (of course most changes are syntax error - just "if foo()" is 7 syntax errors. ) I've seen various attempts of this over the years, but quickly your code becomes more complex than the computer can run while you type and you fall back to running most of the tests after in some way.

>I've seen various attempts of this over the years, but quickly your code becomes more complex than the computer can run while you type and you fall back to running most of the tests after in some way.

That does not match my experience with lisp.

My last experience with lisp was assignments in college which are too small to count as anything more than a toy problem.

For real world code in other languages I've worked with the complexity of the problems demands so much code that the REPL cannot keep up.

> the complexity of the problems demands so much code that the REPL cannot keep up.

Now we disagree, at least in part.

REPL-driven development is in part about incrementalism. You wouldn't run all the complex code every time you want to examine some state or try out an experiment. You would run it once at the start of your session, then compile just the definition you're editing with your editor's equivalent of `compile-defun`.

Of course that breaks if you're making changes that touch a bunch of different areas of your program and require rebuilding all the state, but it's usually a mistake to design programs in a way that would make such an issue frequent.

Mine, either.

I think we're largely in agreement here. Unit tests and REPLs serve different purposes and are poor substitutes for each other; red_admiral was arguing that unit tests obviate the need for REPLs.

REPL isn't just more ineractive, it's open ended.

I.e. you could execute a unit test in a REPL (after e.g. loading the test), but you can't run a REPL in a unit test - you can debug a test and maybe do some REPL like things, but, it's not the same at all...

You also can't write a unit test in a unit test, you can in a REPL.

Heck, an AI chatbot is a (non deterministic) REPL (it reads, evaluates, and prints something)...

Like others were saying, they are different, i.e. nothing at all alike, tests do not obviate REPLs...

The best is kind of debatable as it lacks the IDE tooling from LispWorks and Allegro.

>The best is kind of debatable

I used the word "arguably" in the very first word of that sentence:

>Arguably the best is SBCL

The word arguable is a synonym for the word debatable.

Yes to all that but still, my pet theory is that languages rise on one or two "killer features" that move the entire industry forward, and not the overall cuteness or lovability.

I can suggest a list of one killer feature per each popular language, i.e. things that these languages were the first to introduce and influence many successors:

C: extreme conciseness

C++: implicit destructors / RAII

Python: removed curly braces

Java: extreme portability

JavaScript: erm...

PHP: embedded in HTML by design

Rust: compile-time memory management

Swift: structured concurrency (pre-6 was probably just pure cuteness)

etc.

C is not "extremely concise". Lisp, and especially APL both predate C and are more concise. To me, the "killer feature" of C is UNIX, we can't really separate them, C won because UNIX won and vice versa. Other than that it is reasonably concise, reasonably portable and reasonably low level. The language itself doesn't have any "killer feature".

For Python, I think its killer feature, related to the removal of curly braces is that it is a dynamic language (like Perl) that forces you to write somewhat readable code. You have no choice but to indent correctly, and there is a strong "pythonic" ideal way of coding, the complete opposite of Perl's "more than one way to do it".

JavaScript killer feature is obviously its integration in browsers but it is also well designed for this task, with pretty good support for asynchronous programming.

Still, I don't think any of these languages were successful for their "killer features", more because of a combinations of many things. In many cases, they weren't even the first. For example, there are several langages that use indentation as syntax that predate Python. ( https://en.wikipedia.org/wiki/Off-side_rule )

C++ succeeded because it was Object Oriented, people didn't start talking about RAII as C++ killer feature until years later

python succeeded because it wasn't Perl's TMTOWTDI, everyone expected ruby to overtake python, but .. for some reason that never happened

swift succeeded because apple pushed it to replace objective c, that if you consider swift succeeded

anyway, i agree with your premise, languages need one key strategic advantage feature to succeed, but you just got it wrong on few of them .. and if i am wrong too, then the premise is weak, if we are not sure what the killer feature is, we then have no idea why the language succeeded

I don't think C++ succeeded because it was object-oriented. I think C++ was object-oriented because classes were an abstraction that could layer on top of C with fairly low overhead, giving it more expressive power without much mandatory cost to size or speed.

In other words, object-orientation was the means, not the end.

Back then OOP was all the hype and inheritance was cool.

C++ predated the OOP hype cycle and triggered, or at least accelerated it.

Agreed and that's probably the second major killer feature of C++.

> python succeeded because it wasn't Perl's TMTOWTDI, everyone expected ruby to overtake python, but .. for some reason that never happened

Ruby allows (and to some extent encourages) unreasonable code.

It's not bad code (and in some cases extremely elegant), but it's code you can't reason about.

Being able to open any class (or object) and add new methods to it makes tracking how execution works extremely difficult.

The language allows for very undisciplined things to work - its great for the "scripting" and rapid prototyping - but unless you're going to throw it away the next day of having to maintain that code it starts weighing on the future speed of working.

Undisciplined code can be handled by making sure everyone on the team is disciplined in its use and documenting how things work... but that rarely reflects reality.

And so, you move to a language that enforces more discipline in how one uses it and is more reasonable in its execution.

Ruby felt like a better Javascript, but JS ran in the browser, and so had the constraint of the DOM...

Aka you have to be (more) disciplined within the constraints of the browser.

I'm not saying JS was good...

The lesson here being, complete freedom is fine, as long as you are also able and willing to implement a strategy to verify your operation, ruby on rails, js in the browser, python PEP or pythonic ways...

I came to ruby from the perl side. It was "here's a Redmine server, here's a feature request for one of the in house built plugins." I forget the specifics (it was 2011) ... but trick of the feature was to add a function to the object being created so that it would have the function some other module was expecting. And it worked...

Things like that made me give it the sideye for anything more than I could keep in my head at once... if I started needing to look at other files to determine if there was anything odd there... "can I create a function here in this parameter passed to me? What if someone else created a function of the same name before they passed it to me and expected it to remain?"

It can work... but it requires a bit more discipline than the developers I was working with had as a baseline (for that matter, a decade and a half later at a different job with a lower baseline and AI code - the idea of that terrifies me).

It's a "powerful" language, but I think it has too much power.

I like groovy for much the same reason that I liked perl and ruby (to an extent) - but it too is too powerful. It's great for writing scripts where it's a file or two or three... but if the "what does it do" gets too large to keep in my mind at once then it requires more discipline. I like to think that I have that discipline when working solo in groovy (and people will tell me I don't need to be that explicit in the objects... creating a class file rather than just shoving anonymously built objects into a hashmap), but that's how I can come back to old code more easily.

Ruby Conf 2011 Keeping Ruby Reasonable by Joshua Ballanco https://youtu.be/vbX5BVCKiNs

Abstract Heresies : First-class environments https://funcall.blogspot.com/2009/09/first-class-environment...

C++ succeeded twice.

Initially, it provided a thin object-oriented abstraction over C. This solved many problems scaling large C projects. It set baseline expectations for languages that came later. Being a "thin object-oriented abstraction over C" has significant limits. By the 2000s, it was clear that C++ couldn't scale complexity in the way we needed it to. It was slowly dying.

C++ reinvented itself as a functional metaprogramming language starting with C++11, providing an even higher level of abstraction. Many deficiencies in the older language and systems languages generally were addressed. This was a huge success, creating a large resurgence in adoption and setting new expectations for what a systems language should be capable of. C++20 looks like a completely different (and much better) language than C++98.

I view C -> legacy C++ -> modern C++ as the evolution of a single language. Each was wildly successful on its own up to some level of complexity. Every time it runs into a practical limitations on scaling complexity, it adds a new layer of abstraction. As much as people complain about it, this strategy has clearly been successful.

This is an interesting take, although I'm not sure the legacy -> modern evolution is perhaps quite as significant as you make it out to be. Smart pointers and better std library constructs are absolutely welcome, metaprogramming is nice, but perhaps out of reach for many programmers (so not the "fun" or "successful" part of the language)...

If you were to compare the transformation with another major systems language, or a popular dynamic language, it doesn't feel like the evolution is quite as dramatic as is made out to be?

Rather, the staying power comes from elsewhere, and the language continues to modernize, perhaps at a slower pace than other contemporary languages experiencing similar staying power(s)...

C came with an OS. C++ came with compatibility with C and at the peak or near peak of OO hype. Javascript came with the browser making it probably the most widely available language platform. Swift came with Objective-C compatibility, an OS, and money (iOS app store customers spend more on apps than their Android counterparts).

Coming with a platform that is widely available or compatibility with an existing language on a platform was the killer feature for each.

Yeah, this is a more honest assessment than the others I've read here.

Of course them being ISO(like) standards with competing implementations/tools was also important for C, C++ and Java as the cost to use and learn them was higher in the days before free open source languages, free tutorials and help forums became so wide spread.

But yeah official platform support and big company backing are a big part of why these languages have stuck around compared to others.

Java came with Applets/Web, VB and Delphi with Windows, TP with cheap compilers for PC on top of Pascal university adoption,....

To have a theory of success, you have to also be able to explain failure. Why did object-oriented C (aka C++) take off but object-oriented Pascal (aka Delphi) not, despite the fact that Pascal was as prevalent as C in those days? Why was Python able to overturn Perl's dominance in the scripting space, but Ruby was unable to do so? Why did Ada and Smalltalk never achieve significant dominance?

A lot of success does come down to being in the right place at the right time. JS was successful because it was the only available scripting language for the web (although MS pushed VBScript for a bit) when there was a concerted effort to kill off the Java and Flash plugins. C was successful because it was tied to the Unix OS, which happened to overtake other OSes for a variety of reasons.

I believe JavaScript's was running in the web where Java could not (iPhones) or was considered too heavyweight (no startup).

Then it became the true extremely portable language, because developers wanted a single language to write webapps in, and it was easier to get JavaScript running on their server than a new language running on every browser.

Javascript didn't need a plugin, unlike Java, and could directly alter the page contents. One of the first heavy uses was Google Maps, interactive JS-based applications took off at that point. Then with an army of web developers (meaning in browser), Node took off when it handed them a way to work on the backend in the same language.

The iPhone came out after JS heavy pages came into existence, and might have accelerated the end of Flash and Java applets but the trend was already there.

Gmail was the original AJAX woah! JavaScript application.

Somewhat ironic, since AJAX was originally created by Microsoft to implement the Outlook web client.

Microsoft was early and late to lots of things. They dominated early smartphones, too.

JS despite its (many) faults still allowed a fairly functional style way before that was mainstream. Java and C++ only got lambdas decades later.

Let's be real here. JavaScript didn't take off because it was functional in the functional programming sense. It took off because it was built in and procedural. You didn't need to muck around with objects if you were a total noob. You'd just write your functions and call them with strings as parameters.

Javascript took off because it was your only option for a lot of things. Flash and Java tried, but both were always hit and miss as to who could use it. Everybody had javascript in their browser so you had no choice if you were to reach them but meet them where they were.

and despite all of its shortcomings, the ecosystem really grew. There are mainstream languages that to this day still can't match npm (looking at you, Python)

I like that theory, if I was going to counter it though, I'd say that I'm not sure those features match what language users talk about. For instance:

- C: Users often praise the simplicity of the language

- C++: Users often praise (not always praise?) the large feature set for a low level language

- Python: Folks talk a lot about "batteries included". Although in all honesty, I think having good interaction with other low-level languages is Python's secret feature.

- Java: Really leans in hard to object oriented programming

- JavaScript: Haha, you have to use it!

Not sure I'm really disagreeing with you though, but I think Java promoted its portability much more than it's ever been used (obviously there are cases like Spark which uses the JVM portability).

Swift: (reaon reason->) only Apple recommended language of choice for SwiftUI and iOS/macOS development.

Swift could be the worst language in the planet and people would still learn it. For considerable amount of time, its compiler used to timeout for many code-bases and people still gritted their teeth and learned it.

Except for PHP I don't think that's a very fitting list. C for example, is not really a concise language, not even for its time - APL is much more concise. C is rather verbose.

Likewise, Python is not the first language without braces - and it debuted before braces became the industry standard. I guess ISWIM or ABC are the first to have syntactic whitespace.

Really, you will always find an earlier example for a "killer feature", at least in an academic context - in the case of your list, usually in the 1960s, in the 1970s at the latest.

this is just survivorship bias. I bet you 1000 dollars that there exists hundred languages that are more useful and well thought than those languages you listed, but still nobody cared and it died.

I believe the reason lies entirely outside of the language itself. let just say, the is a circle, a society (of programmer and related peopel) that decide that a language can be popular or not. if your language get picked, then it will be popular, if not, then good luck.

you can deduce easily what the criteria (to be picked) from the list of languages you mentioned: 1. if it does not come from US, good luck (ruby is an exception but it didn't sail until some americans decide to boost it) 2. if the language authors do not speech english well, good luck (I mean, sure if you advertise your language more more people will pick it) 3. if you satisfy 2 previous conditions, if you do not play along well with those people in the circle, then good luck (D is a good example of this) 4. even your programming language is dog shit, as long as you know the people in the circle, they will promote it for you. bonus point: if you allow the language to be directed as they want, then it will be extra smooth.

tl;dr: it is mostly politic how a programming language gets popular.

To add a few more exotic cases that affect things. Keep in mind that by default new languages fail. To succeed, many things have to all go right at once, and this implies that therefore there is not one single element that, if gotten right, means the language will therefore be successful (it's rather the opposite: If even one of the key factors is wrong, it'll probably fail).

* It's just a guesstimate, but one of those factors that caused java to be successful but-for (as in, if it hadn't had this, it wouldn't have been a success): It copies C style religiously anywhere it could get away with it. This caused some damage to the language that it has fixed in the past decade (such as the style and behaviour of `switch` being so bizarre - but it religiously follows exactly how it works in C!)

* Some languages end up failing partly due to community outlook. Scala is somewhat well known for having a core community that is highly aggressive and elitist, or to be a bit milder, to be 'less accepting of newbies with a limited understanding of programming concepts' than is optimal'. And in addition to that, they are in contrast to the java ecosystem ready to drop support for stuff quickly, meaning: Real life actual use of scala as a basis means you're either working with a hopelessly obsolete codebase or you're spending time refactoring it every other month pretty much. Scala's adoption is fading and never got anywhere near its hyped future.

* If a language is 'native to a platform' which I define as: "If the shepherds/owners of that platform were to write a basic app for their own platform, what language would they write it in? That's the 'native to that platform' language", then it tends to succeed even if it is not fun and not very well designed and even if transpilers exist. This is sufficient explanation for me for the success of javascript: It is the native-to-the-platform language if the biggest platform around.

These all fit within the thesis. They're all (last one is debatable) very human factors.

On scala, I think there were several factors that led to it stalling out in the mid to late aughts. I am not convinced the community was the root cause. I think more significant was the scala 3 transition. When they were still near the peak of the hype cycle, the core team decided to spend more than five years rewriting the compiler. In my opinion, while there were good reasons to do a rewrite, they focused on the wrong things if widespread adoption was the goal. The biggest problems with scala were compiler and sbt performance, as well as related dev tooling. The new scala 3 compiler had to first approximation equivalent performance to scala 2 and they did nothing to improve the build system. In the meantime, other languages that overlapped with scala in various ways rose up: kotlin, typescript and rust come to mind. The unique value proposition was diluted, and the poor tooling experience persisted.

Now, that's not to say that the community was not also a factor in scala losing momentum. I agree with your take. At the same time, that elitist community was also building cool and useful stuff that significantly improved upon what was available in other ecosystems so I think it was a double edged sword. Even today, there are things that are easily done in scala that are useful, elegant and impossible to do directly in most of its peer languages. It may never have reached truly mainstream ubiquity but I think with better technical decision making, the language could have remained very strong its niche.

I'm calling bull on this. Learning languages, at certain points, is always tedious. Whether that language is a computer language, or something like Greek, there comes a moment where "trudging" begins. The reason a person "trudges" is that they have a goal in mind that makes the trudging something to endure until that goal is achieved. Fun comes from not having to solve the same problem sixty times, or having to sort through a million files by hand when a program can do it in 3 seconds.

Hmm. I find learning fun, no matter what the scope is - even Greek, which remains obscure to me. (Quick, ask me something about Greek! I'll nod wisely and stroke my chin in deep thought and then get distracted and wander elsewhere.) But you're not wrong: there's a fun discovery phase, then a "hey, does this actually work" phase, and then a "crap, I need to figure out how to MAKE it work" phase, all of which are decision points where one might choose to not bother.

It totally depends whether you're still experimenting and learning or not, which is totally circumstantial. Sometimes I slog through things at the start, on the promise that they will start to be fun once I see the point.

Easiness is fun because it enables more messing around and learning. Not having to solve a problem is not fun, because problems are learning opportunities and are fun, unless they're just trivial obstructions in the way of the real problems of interest.

Indeed! That's how it works, pretty much every time, unless language choice is dictated from above, which ALSO happens.

(And is why I know COBOL today, although I'm probably stronger on COBOL-77 than COBOL-85, when I STARTED COBOL after COBOL-85 was a thing.)

Maybe not "fun", but people have preferences, not necessarily rational, in the choices they make. Programming languages, technologies, and even fonts.

Some languages are more enjoyable to use than others. I'm sure there are features/syntax/constructs in languages that you irrationally don't like.

The stewardship and economics of the language can also be the issue. I started coding in the 80's and so web development for me evolved at the inception of the field. I will go to my grave insisting that Coldfusion was a better platform than PHP, but it was always commercial with a financial barrier to entry. PHP being free led to a glut of PHP developers, low-cost hosting, and an enormous ecosystem that ultimately redirected the course of the early web.

It's ridiculous to call Objective-C "a false start".

1) Objective-C is 40 years old.

2) Objective-C was used to create NeXTSTEP and by extension Mac OS X and iOS.

3) Objective-C is no more "awkward" than any other programming language. I actually prefer its verbosity to Swift's terseness.

4) Although Swift did eventually become more popular, the claim about Objective-C that "the moment Swift existed, it evaporated" is not only false but a gross exaggeration.

OP here: Fair. Yet I'd say that it's relatively rare (while being completely absent in my experience) that anyone would choose ObjC today - and the article even mentions Pascal as a stronger example of the model you use with ObjC. ObjC survives today, as does Pascal, but its strongest impact is through influence, just as with Pascal.

And languages being awkward is entirely a personal opinion, agreed. You might think in ObjC. I do not. There's nothing inherently wrong with either of us on those grounds.

> Yet I'd say that it's relatively rare (while being completely absent in my experience) that anyone would choose ObjC today

There are a number of pragmatic reasons for this. Nobody is teaching ObjC anymore. Apple's documentation is now mostly Swift. Apple recommends Swift (and SwiftUI, despite the fact that many SwiftUI users have found it severely flawed). The job opportunities are mostly in Swift. I would say they're actually the same reasons people adopted ObjC back in the day. (Some other options were available, e.g., Carbon in pure C, Cocoa-Java.) Moreover, some newer Apple API are available only in Swift. Thus, Apple is pushing people into Swift whether they like it or not.

> There's nothing inherently wrong with either of us on those grounds.

Except that the thesis of your article depends on Swift being "more fun".

My belief is that Swift became popular among Apple developers for the same reason that Objective-C did before: Apple promoted the language. People jumped on Swift because they felt it was "the future". Some people were already claiming in 2014 that every line of code you write in Objective-C was "technical debt". Such claims turned out to be absurd, because old ObjC code still compiles and runs, while Swift 1.0 code does not.

Well, the problem here is in your own words: you say `My belief is` - and so it is. I cannot and would never presume to tell you what you believe. Yet I believe otherwise. Swift won on multiple axes; ObjC is still around but feels like legacy to me, much like Pascal does: influential (heck, I use ObjC terminology when describing OO concepts, over Smalltalk!) but not, like, a living language at this point even though its death might be, um, a lot more rumor than fact.

> ObjC is still around but feels like legacy to me

Yes, it feels like legacy because Apple is making it into legacy. Do you not admit that Apple's actions have a profound effect on the relative adoption of the two languages among Apple developers?

I would note that Swift is, like Objective-C, almost nonexistent outside of the Apple ecosystem, even though cross-platform use is possible. Developers who are deliberately outside the Apple ecosystem are generally not interested in a programming language controlled by Apple.

And yes, you're absolutely right. Apple is making a choice here, and they absolutely have impact on what the developers "get to use" - much as .Net succeeds largely to vendor choices on Windows, too. And developers get to suck it up! That's the three axis thing again: vocation, art, job. Swift and .Net both got a huge kick from the "job" department. That's how it goes.

> That's the three axis thing again: vocation, art, job. Swift and .Net both got a huge kick from the "job" department.

Granted, Swift got a huge kick from the job department, but what you wrote said a lot more than that:

> A language that makes life hard will not survive past the moment it can be replaced.

> Objective-C was awkward as both art and job, and it thrived for fifteen years because it was the only door into the most lucrative developer ecosystem ever built; the moment Swift existed, it evaporated and now survives as a shadow, preserved in its descendant.

Apparently you're admitting now that "the moment" is a gross exaggeration. You're also admitting that the "art" aspect is controversial, a matter of personal opinions that vary. I'm not sure why you claimed that Objective-C was "awkward as... job" even before Swift existed?

I wrote that it was awkward because IMO it was. That is indeed "my opinion" - I found the language it used to express concepts far more useful than the language itself, and found myself writing C++ far more often than ever wanting to write ObjC.

It's unclear whether your last comment is talking about the art or the job axis, the latter of which I just asked about.

I certainly don't see how using C++ would be less awkward on the job for developers than ObjC when the job was primarily calling ObjC system API.

ObjC "failed" because it was locked inside the Apple ecosystem, and Apple made no serious effort to change that. Ref counting aside, I thought it was a wonderful fun language. But it was always platform specific in a way that other languages aren't.

Compare with C++ which is widely hated, not because it's virtuosic - it really isn't - but because it's a bug-prone incoherent pile of archaeological standards and object bureaucracy, and most users only work with their own personally curated subset of it.

It's true some people like C++. It's widely used because it runs very, very fast, and trades that for slow compile times.

But some people also like jumping off mountains and trying not to hit the sides. I'm sure it's quite a rush on the way down. But not ideal as a daily commute.

>That quote is the article, and it's a little surprising that it's buried so far into the content

Is it really surprising in 2026? Today's online writing style is not primarily designed to communicate. It's designed to keep the reader 'engaged' for as long as possible. The reader's time is a resource to be extracted.

I'm absolutely not poking this author individually. It's the writing style of the net

Yeah, and I despise it. :D I purposefully expose the lede in my own articles early and often and as up front as I can make it - the editorial reviews keep saying "you should optimize for the clix, maing!" and ... no. If someone doesn't want to read the crap I come up with, I want them to know they don't want to read it right out of the gate, personally.

Unfortunate how many languages with interesting stories were either glossed over or omitted entirely.

Clojure was an outright revolution against Java’s boring clumsiness, and many businesses are quietly making money with it today. Hickey even _explicitly_ comments on expertise (the OPs discussion about Rust and C++ being worth it) in the context of learning to play the violin.

Ruby declared itself as being all about “programmer happiness”, and while probably not as specifically a rebellion against Java, it attracted a ton of burnt out Java people who went on to found thousands of startups on Ruby. Ruby continues to be massive for web apps, Rails is still extremely popular compared to many alternatives.

Scala similarly to the previous examples was a Java-like with Haskell flavor that escaped an academic lab and accidentally took over the “big data” craze in the 2010s because they wrote Spark in it. If you were around then, Scala was truly hot at the time.

There are others of course but I found the examples in the OP a relatively surface level analysis of a space that has experienced an absolute explosion of diversity and novelty in the last 20 years.

Totally fair, but as I mentioned elsewhere, I left a lot of languages out in my consideration even when they're on my CV. Heck, I work in Java in my day job - I'm taking time away from it to write this comment - and realized after I'd finished my third draft that I didn't mention it at all. And I DO Clojure, have done Ruby, have done Scala (and will never do so again if I have any choice in the matter).

I could have gone into each language as a sort of postmortem - even for the ones that aren't dead right now - but for every one of them there'd be a host of people saying "wait, you're wrong" and they'd be right, and maybe I would be in that host saying I was wrong at the same time. (Again, see the footnotes: it's right there!)

But the piece isn't abotu a postmortem analysis of whether a language is fun or not - what I enjoy isn't going to be what you enjoy, nor should it be, and I don't care what you use, as long as you use it well and for the benefit of mankind.

I've also researched languages and written a similar piece[1]. Most successful languages had adoption momentum outside of the language itself. Conversely, there are many interesting failures—languages that were technically fascinating but ended up having their ideas stolen by later successful languages. A language isn't like a paper; it doesn't compete solely on the quality of its ideas [1]https://www.makonea.com/en-US/blog/programming-languages-are...

I wouldn't call it stealing ideas, all languages build on ideas from older languages. language design is more akin to a academic discipline building on top of each other, languages have lineages like a family tree. Language users have usually no idea about the ancestry of the language they are using. Like Ruby borrowed heavily from Smalltalk, nobody is arguing Ruby stole from it.

But I agree the adoption is the key factor, more people using a language grows the ecosystem and it becomes self perpetuating from there. This is why I disagree with the article, I don't think python is a good language but I still wrote hundreds of thousands of lines in it over the last decade, not because it's fun but because of its strong ecosystem fitting the task at hand.

Agreed. I think people tend to forget that:

you do not have to pick a single language. it is trivial to use another language just for that single library. there are many way to communicate, it is not like method calling is always the hard requirement

since you do not have to choose a single language, the killer feature of that language is mostly useless, even if there is no other language that have the similar feature, people would just write a some glue code to bridge it with their main codebase. and usually, there is no such thing at unique feature that only that a single language can have. sure, it can be achieved easier in that language for some use case, but even so, a single bridge file is probably enough. aka nobody would invest in your language.

writing software is mostly using other people libraries anyway. the thing we write the most is some common business logic, thus the syntax is extra important, or rather, the DX is the most important thing. heck if the experience is great enough I can throw thousands hours to write the libraries/frameworks myself, it is (usually) not that hard.

it always turns me off seeing a new introduced language that syntax wise is a carbon copy of rust or C. no thank you, if you not even want to think about the syntax, why should we believe that you can deliver something truly innovative?

I would say that out of the box functionality (in the language itself or stdlib) makes a difference these days too. Older languages aren’t really subject to this, but new languages can be hard to justify bothering with if they require you to reach for third party libraries (and all the security issues, drama, etc those can entail) for somewhat common/basic functionality.

I'm retired now but it never occurred to me the vocational languages I enjoyed most were all respectable or false starts (or obscure): FORTRAN, Pascal, Icon, Ada, Tcl.

And in hindsight, I only grudgingly accepted the immortals, although I recognized at the time they would be widely adopted: C, C++, Java, Javascript, and Python.

Is awk still respectable? Is it even a programming language?

All of them are respectable. I've done most of those - Icon's new for me, and I don't think I've ever written anything in Ada either although I've come unfortunately close thanks to industrial requirements. I escaped!

And yes, awk is a programming language. And respectable. I tend not to use it much any more, but that's because there are other things that feel easier than remembering the syntax. C'est la vie.

An interesting example to look at is Java vs. Kotlin. While Kotlin is a bit easier and definetly more fun, it didn't manage to gain a big market share in the Java space so far. I guess that this is the case, because Java is good enough and seems to be the safer bet (at least for managers).

The problem here is that "mechanical empathy" is for most neurotypical humans at odds with fun. It's hard to say that static typing is "fun" but at this point the benefits are so abundantly obvious that it's been shoehorned into Python via Pydantic and MyPy/Ty

I'd argue as well that "fun" for a lot of programmers seemingly entails over-abstracting, inventing complicated interfaces & following Clean Code dogma etc.

I think there's an inherent tension between what's fun and what is actually good software from a purely mechanical standpoint of performance and functionality

I think in terms of niches and fitness

Programming languages are under a Darwinism-like pressure of programmer's attention. They have to fit a niche, and the ones that fit the niche best, survive. What another commentator calls killed features is, to me, a way to fit a niche.

Sometimes that niche is fun, like Python. Javascript's niche is that it's literally the only option. I suspect some languages (Java) fill a niche because they've been there for so long there's no oxygen for anything else to have a chance.

For quite a period up to LLMs, coders had high amounts of social power and gleefully asserted it by e.g. flouting dress codes and asserting their preference in tool choices. This is why we still see articles like this arguing everything from a point of view akin to that of a hobbyist, rather than articles by heads of engineering establishing that this kind of screwdriver is optimal for industrial automobile assembly.

Note: am a head of engineering, and I've been writing code both as a vocation and a job for decades. I see it from a lot of sides; maybe not EVERY side, I'm not a machine (yet), but I don't think I have a singular myopic vision of ANY of it. YMMV.

All languages are fun, but the most fun programming languages are ACPUL, Lisp and fun esoteric languages like Brainfuck. Enterprise made programming less fun while the most popular languages are popular mainly because huge budgets are allocated not only to promote them across every platform, but also to pay salaries.

> For the person who only wants the notes, the sampler wins the job outright, completely. It will never play the wrong thing or at the wrong moment. For the person playing, it fails, because driving it costs more than playing, and it never touches the art at all.

This entire essay could be about AI adoption as well. Some programmers love to program, and while AI is great at producing the code, it doesn’t really viscerally appeal if one loves coding itself.

OP here. Yeah, you're not wrong. A lot of what IS driving AI code is that the writing code part isn't the intriguing aspect: it's designing, and the code generation is the grunt work that makes the design happen. And then you find out that most humans aren't that great at design: most programmers handwave their way through specifications, and thus the AIs do what they're told, and generate utter dreck, a lot like some of the "melody generators" do - they get handed very artificial constraints about what "good melodies" sound like, so they all sound very ordinary, because they STILL lack soul and replace inspiration with algorithm.

> AI is great at producing the code

It's not. The latest-and-greatest models on $200/mo subscriptions routinely produce bloated code full of boilerplate. They are incapable of producing elegant, concise, readable, correct-by-design code - they literally can't do it, even with the smallest samples, and it gets much worse as the scale of the implementation increases. You can't will the capability into them through prompts. You probably could do so with fine-tuning or other techniques, but I suspect that would just make the variance higher - and the average code quality would be much lower than it already is.

The code generated by LLMs is passable, but never truly good. The same is true for LLM-generated designs and architectures, just even more so. They are trained on all the code out there, and the percentage of really good code is so vanishingly small that it's incredibly hard to replicate even for humans after a lifetime of learning. LLMs would need to reach a next level of capability to consistently recognize good code. Generating it consistently is out of the question for at least the next few generations of the AI.

Not all code has to, or needs to, be good. LLM-generated code is useful and helpful. It's an incredible time-saver for one-off scripts, and you can make an LLM implement and maintain parts of the program you need, but don't care to make good at the moment. LLMs are very efficient (if we ignore externalities) and easy-to-use code generators, which is huge in itself. However, they are not great or even good at generating code.

Last weekend, there was a post showcasing a Rust library with utility functions for writing parsers. It featured a simple line-by-line INI file parser. I decided to rewrite it in Python with PyParsing, a library I happen to know well. GPT-5.6-Sol High wrote the grammar that worked. It was tragically bloated, poorly factored, and multiple grammar problems were masked by parse actions. It worked, but it was decidedly bad code. I then rewrote the grammar by hand, getting it down to 1/3 of the length, eliminating all parse actions, and improving error messages in the process. I then spent 2 hours trying to convince the model to perform the same refactorings I did, but had to give up: no matter what I tried, the model couldn't get all the needed changes to coexist at the same time. When it got the terseness right, it inevitably ruined error handling. When it got the grammar right, it ruined the factoring. And so on.

Later on, I decided to make the model rewrite the PyParsing grammar in Smalltalk's PetitParser - a pretty close match in terms of capabilities. I gave the model my version of the grammar. I told it to translate that Python code. It still butchered more than half of it, doing "optimizations" (the model's words) that replaced a cached production with a literal + 3 message sends in 8 places in the (trivial!) grammar. I explained what I value in the original code, why those are important features to keep, and tried again. It still couldn't give me an idiomatic Smalltalk translation, though it did get significantly closer. I concluded that the model has a very limited understanding of how concepts I wanted can manifest in actual code and called it a day.

To give you an idea of the scale: excluding blank lines and imports, the grammar is exactly 10 lines of Python...

So no - LLMs are not good at generating code. They are just fast and convenient, and again - that's huge. But it's nowhere near a level where it can be steered to produce good code - much less being able to generate good code by default.

(I realize this post is a bit off topic and it's just an anecdote - but I've experienced this daily for the past half a year; I'm not basing my opinion on just that last attempt.)

Yeah, definitely on point. I use AI for code generation, but I ride herd on it quite a lot and I limit scope viciously and with hard rules about what the models are even allowed to generate. It's worked out pretty well, but it's hardly the "oh send a question get a full system back" that people try to pretend it is.

Heh, the article is kind of negative about Haskell's "success", but fun is exactly the reason why I still prefer Haskell over all other languages.

Hey, I actually made a point out of laughing about it even as I wrote it - see the footnotes. Haskell's dedication is actually quite remarkable and respectable, and it's not "against success" but against trading "correctness" for "success."

I'll be blunt about this:

It's probably also the reason statistically no one will be employed to work on a Haskell code base. Same for Lisp, F#, OCaml, etc. They're the hot rods of the software development world where everyone uses SUVs.

What kind of workplaces you people have if you can code "for fun"?

I am tired of only ever being gauged by immediate usefulness. You hiring?

Also when you emphasize "exactly", you are not giving any actual reasons.

I code for fun and income. I don't stay at engagements where I can't invest personally in what I'm doing, and I don't hire people who don't enjoy what they're doing as they're doing it. Anything else feels punitive for everyone involved.

> C, C++, and JavaScript are immortal (for now!), with Java a maybe

Feels like someone hasn't spent much time in the enterprise. Java is still doing pretty good in that space

Well, my real name is Joseph Ottinger. I've been writing about "the enterprise" and Java since around 2000, as editor for TheServerSide.com, Java Developer Journal, and writing multiple books on Java, as well as writing Java code for a lot of people for, well, decades. Java's doing all right. Java's "immortality" is still in question; it might be the next COBOL, but I don't pretend to know the future and I can see a world in which something eats Java's lunch TOMORROW, although I don't know what that something is yet.

I tried to read this with an open mind but the premise of the article is so reductive I gave up quickly.

There’s a whole plethora of reasons a language might fall in or out of favour. From ecosystem lock in (eg Objective-C was mandatory for Apple development prior to swift and Visual Basic was ostensibly killed by Microsoft during the dot net upsell) to fragmentation in the community (eg Perl vs Raku). These don’t mean the languages aren’t “fun” nor productive.

Likewise, “fun” is such a subjective term that it’s utterly meaningless using it as any kind of yardstick. Esoteric languages are arguably the most “fun” but you don’t see companies running critical infrastructure on Brainfuck, Rockstar, nor lolcode.

And to say Pascal, Perl and Objective-C were false starts only demonstrates the author hasn’t used any computers prior to 2010. Perl was the de facto sysadmin language for literally decades. Pascal was the microcomputer language of choice before C++ took over (even to the extent that some 80s OSs are Pascal projects), Objective-C only disappeared because Apple introduced Swift. And the authors comment about COBOL being retired is untrue for anyone who’s worked on critical banking software.

I honestly think AI slop would have more value than this naive opinion piece.

Also, since I tend to loop back: yes, "fun" is subjective, and your points about Objective C and Pascal were actually mentioned directly in the footnotes, including the "false start" nomenclature, which came from Oram, not me, and I mentioned COBOL's specific remaining survival directly as well. Comments are always appreciated, of course, but they're best when they actually address the article they're commenting on instead of inferences. I get that the article's not short - I don't enjoy 300 word things that lack nuance - but even so.

Maybe you shouldn’t open with such provocative statements if you are already aware they’re not fair?

Posting flamebate and expecting people to read until the footnotes isn’t going to get you favourable feedback.

It's not flamebait - or "flamebate" - and I don't write "for favorable feedback." Did you not read the article? The author - me - actually means every word of it, including the bits about vocation and joy. Life is not single-dimensional, and neither is knowledge.

> yes, "fun" is subjective, and your points about Objective C and Pascal were actually mentioned directly in the footnotes, including the "false start" nomenclature

I didn’t get as far as the footnotes because the article glossed over so much nuance at the start that it felt like I was reading something from a 20-something fresh out of college. And by your own admission, you have to read to the footnotes to get to the nuance. Maybe it does get better towards the end, but then that’s a failure of the writing if you have to read the first 90% before you finally get to anything insightful.

Plus it’s not just me that disagreed with the premise of the article. Reading the comments afterwards, others have taken away the same thing I had.

I’m sure you’re a competent author and your other submissions demonstrate more thoughtful insights. But unfortunately this one misses the mark. It’s just far too reductive for far too much of the article.

Totally fair, totally understood, such is life, which is why the very first paragraph says what the whole article then articulates in more detail. :D

I do this weird "tell people stuff up front" thing where I don't like clickbait titles, don't prefer the simple thing to the true thing, use opening paragraphs as actual theses - or close to it. If you read the first paragraph, you got the gist. The footnotes are footnotes because having interspersed aside text isn't convenient to write.

I was programming computers in 1981. Pascal and COMAL were among my first structured languages. Your comment on the "naive opinion piece" is taken as it is offered, and I'm happy to offer you a full refund on your purchase price of the essay. :D

Perl is still in every Linux. I just checked one of my Oracle installs and there are 725 .pl files.

So it seems that is it still relevant.

exiftool is still best in class in its arena.

> Different diseases, one pathology.

> Sort the corpses that way and they separate cleanly

Just like when you get a bit of meat on the bone in a stew, and it all comes out as one piece - but it's just on the brink, and the slightest of touches with the fork is enough to make it separate cleanly, and it just slides off perfectly.

I love it when that happens. I really feel like the author does too. That's part of why I like reading things written by people. Shared enjoyment of a shared human experience.

Here's another one of my favorites: pulling a huge weed out of soft, loose soil and hearing the crackle of the roots as they come up out of the earth.

Reply on news.ycombinator.com