12 ms·
Minimalism in programming language design
- dmitriid 4y agoRelevant. Guy Steele, Growing a Language https://youtu.be/lw6TaiXzHAE https://youtu.be/lw6TaiXzHAE
- deleted 4y ago[deleted]
- lifthrasiir 4y agoThe text version: https://www.cs.virginia.edu/~evans/cs655/readings/steele.pdf https://www.cs.virginia.edu/~evans/cs655/readings/steele.pdf I feel though that the article hasn't aged well. The talk was given in the age where Java didn't yet have generic types (he mentions this alongside with operator overloading). As to how Java successfully grew since then, I'm not very sure. Not all faults of Java are his, but like many others, he only seems to have a (very good) idea about the general direction, not the path itself.
- ackfoobar 4y ago> the article hasn't aged well He mentioned generics* is needed to "grow the language". Then Java added it, making the language more expressive. This talk aged like fine wine if you ask me. * and operator overloading, and value types. The former I'm happy using in Kotlin. The latter we will have to wait. But for code that is not performance-sensitive, data classes/records work just fine.
- Twisol 4y agoAs a mild counterpoint, I'm anything but upset with the recent additions to Java. It feels like it's becoming a simpler language, as in many cases, it takes much less effort to tell the compiler what I want to say. The conceptual tools Java provided at its inception just weren't enough to express things well. In a similar way, even though the lambda calculus, SKI combinator calculus, or and MOV-only assembly are minimal in very real ways, the cognitive burden of expressing yourself in these languages is very, very high! To pick a friendlier example, I'm a big fan of Lua. Lua is deeply minimalist, and from what I know, its developers try hard to keep its feature set orthogonal (and it has my favorite language feature, coroutines!). It's a great fit for certain domains. Nonetheless, it's not a great fit for most domains; for instance, I never got the sense that it could scale much beyond one-person projects. General-purpose computing languages are in a bit of a catch-22. People need to do such wildly varying things with them, that in order to be minimalist, they must necessarily put some distance between the features they provide and the use-cases they are applied to. Conversely, to be expressive, they must minimize the amount of encoding required to take ideas in the problem domain and represent them in the language. A domain-specific language (with high expressivity for the problem domain) invariably tends to take on general-purpose features, as users' needs expand and they push the language to its limits. A general-purpose language (with low expressivity for most problem domains) tends to take on more and more high-level features, to help bridge the gap between the language and the domains it is most often put to use in. I think a polyglot environment makes a lot of sense. Use high-expressivity DSLs to serve your business logic, and high-generality languages to serve those DSLs. In some ways, that's the ideal of Lisp: your DSLs are indistinguishable from the host language itself, so the experience is seamless. But folks don't seem keen on polyglot environments, Lisp or not. So we're at an impasse.
- Rochus 4y agoLua 5.1 is the most amazing language design I've ever come across; you can do almost anything with this language and it's as minimal as it gets. It is true that dynamic typing sets limits in terms of project size.
- giraffe_lady 4y agoHave you ever built anything complex in it though? One of the pains of professional lua development is how much lay users admire its design. And it is true that its design is elegant and emerges from interesting and admirable constraints. In practice though it doesn't give you any of the tools you need to do anything except make tools to do those things. Which appeals to yak-shavers like us for sure. But if you need to sit down with it for months at a time and just get work out the door it fucking sucks. Also 5.1's GC is goddamn tragic. In practice you're usually at the mercy of whatever was implemented by the embedding runtime, but if you're ever left alone with just the raw 5.1 GC you'll wish you weren't. Later versions improved that dramatically.
- snek_case 4y agoCan you elaborate on why the 5.1 GC is so bad?
- giraffe_lady 4y agoHonestly I'm not an expert on that part of the lua internals so I can't confidently say why. I don't think it's a fundamental problem since later versions use the same approach afaik, so I assume it's just implementation nuance. 5.0 used, IIRC, mark-and-sweep which is not great either but it's predictable: it's easy to develop intuition for how much you're allocating and what the collection cost will feel like. The main practical issues I've run into with 5.1: - per-object overhead in time and space both increased significantly, making many small allocations much more expensive than fewer big ones. further pushing you into the "mutate a few huge global tables" pattern that is already a problem in lua conventions. - some of lua's more lauded and genuinely powerful features, esp metatables, don't work smoothly or predictably with the GC. it leads to people trying to manually tune it with __gc metamethods, which is hard to do correctly and causes memory leaks if done incorrectly. - weak tables idk,. esp with strings for some reason. similar to the __gc, there is a solution there but in practice it's very hard to be sure you've got it right and it's worse to get it wrong than to not try. I'm sure a PL expert can explain and justify all this but I am just a normal person who codes for money. Lua is admired for being simple and accessible, but especially in the older versions you get into the low level weeds real fast over this stuff. Kind of a good example of minimal implementation exposing you directly to irrelevant complexity, really.
- webmobdev 4y agoCheckout Oberon (the successor of Pascal and Modula). The whole language guide for Oberon is just 17 pages because it follows this philosophy ("Make it as simple as possible, but not simpler" - Einstein) - https://people.inf.ethz.ch/wirth/Oberon/Oberon07.Report.pdf https://people.inf.ethz.ch/wirth/Oberon/Oberon07.Report.pdf . Mostly Oberon - a series of blog posts documenting exploration of the Oberon Language - https://rsdoiel.github.io/blog/2020/04/11/Mostly-Oberon.html https://rsdoiel.github.io/blog/2020/04/11/Mostly-Oberon.html Oberon to C Compiler - https://github.com/GunterMueller/OBNC https://github.com/GunterMueller/OBNC Oberon+ - Oberon parser, code model & browser, compiler and IDE with debugger - https://github.com/rochus-keller/Oberon https://github.com/rochus-keller/Oberon
- hazelnut-tree 4y agoNiklaus Wirth, the creator of Oberon (and Pascal and Modula-2) has been in the small programming camp all his professional life. I also agree with his views. One of the advantages of small languages is that you can actually learn or master the whole language. However, small doesn't always mean simple. An example is the frequent discussion over Go's supposed simplicity. Other new languages fall in the medium-to-large size: Julia, Nim, Rust, Swift, Kotlin, Crystal. Back to Niklaus Wirth and his thoughts on Oberon: > There was obviously no way [for Oberon] to play an influence next to Java and C# and C++...But yes, I thought, as I did in the Pascal times, the foundations have been laid when a person learns his first programming language. That’s the key. In order to do a good experience, you have to have a clean language with a good structure concentrating on the essential concepts and not being snowed in. > That is my primary objection to the commercial languages – they’re simply too huge, and they’re so huge that nobody can understand them in their entirety. And it’s not necessary that they’re so huge. But people don’t want to see that. Particularly industry doesn’t. I think the industry thinks it’s a big asset to have a complex thing that increases their reputation of being sophisticated. (From a 2018 interview with Niklaus Wirth: https://www.youtube.com/watch?v=SUgrS_KbSI8 https://www.youtube.com/watch?v=SUgrS_KbSI8)
- lifthrasiir 4y agoI think Pascal itself serves as Wirth's own counterexample. When I first learned Pascal it was not the original version of Pascal. It was a Borland's highly extended version of Pascal, then later Delphi. Wirth still has a point as they are considerably smaller than many contemporary languages, but it is clear to me that a bare Pascal wasn't large enough.
- 2sk21 4y agoThis article definitely strokes a chord in me, although in my case for for Swift, not Rust. After I retired a couple of years ago, I decided to develop a Mac and iOS app in Swift using SwiftUI. In most of my career, I used Java, C or Python. Swift, like Rust, is a very complex language. Even six months after I started, I keep learning new language features. In some cases, I had to watch WWDC talks and read the language spec to understand why some features were included in Swift. And even then it left me wondering why they could not tolerate a slightly more ugly syntax, in favor of readability. I should mention that I have been programming for forty years and and I have written several compilers and language run time systems in my career.
- gary17the 4y ago> And even then [Swift] left me wondering why they could not tolerate a slightly more ugly syntax, in favor of readability. Well said. I've also been coding for a couple of decades (mostly in C++) and I also found advanced, real-world Swift unbearably... "irritating", for the lack of a better term. Surprisingly, I do not have that problem with Rust, even though Rust can be quite complex in order to be able to express ideas that Swift cannot handle at all (lifetime, ownership, immutability of reference types, mutable reference exclusivity, dynamic trait types, etc.) Somehow my brain is happy to consume complex Rust, while it's often "irritated" about consuming complex Swift. I think the reason why Rust is so overwhelmingly better than Swift (for me, at least) is the fact that a lot of (ingenious) effort must have been put by the Rust Gods into Rust language >>consistency<< and >>predictability<<. My proverbial "sh*t, I like Rust..." moment came after I noticed a few things: 1.) Rust did not allow me to force-implement the Copy trait for a type that was not actually simply bitwise-clonable, 2.) Rust was expecting the "await" keyword after an expression, like a function call, yet uniquely without parenthesis, and 3.) Rust closures turned out to be based on the very easily noticeable double-pipe syntax. My plea to the Rust Gods That Be: do not ever allow Rust to lose that unique "explicitness" and "predictability". It is one of the language's greatest assets.
- cobbal 4y agoI agree with you on swift. The evolution process seems to favor adding more "features" instead of unifying, simplifying concepts. For instance, we have special syntax for optionals, exceptions, asynchrony, coroutines (mostly hidden), and any other effects they decide to add in the future. Whereas in haskell, all you get is `do` syntax for describing these things. The trade off is that in haskell it's harder to learn the first thing, but then easy to pick up the rest. In swift, you have to learn how all these special effects interact.
- smartmic 4y agoI think it depends on what you want to achieve. If the goal is to quickly create solutions for complex problems, then it helps if the language (as a means to an end) already provides ready-made "features" that you can fall back on. Of course, not everyone will need all of them, but only a subset for his or her domain. I'm thinking of the scientific community, where C++ is very common and almost more like a DSL. Here the finished program is used as a tool for a task, which itself is the final product. So the coding itself is "only" a (sometimes annoying) preliminary stage. You don't want to build important language constructs yourself first from minimalist elementary building blocks. It may be different for professional programmers, whose programs often have a different purpose, are created by multiple developers, and have much more effort put into reusable, clean code. Here, the code base is more the product than the finished program.
- sshine 4y agoA recent observation about the advantage of syntactic minimalism: As a newcomer to Rust, a thing I noticed is the syntactic explicitness around generics: In particular, I had to learn to write Foo::<T>::bar(), i.e. the double `::` seems verbose. But it is also unambiguous that the `<` is not a less-than, because it comes to the right of a `::`. There are other `<T>`s that don't need `::` because they're already somewhere that could only be a type. A human probably wouldn't mistake those. So you might have syntactic complexity in a syntax that is easy for a human to wrap their minds around, and perhaps even makes expressing yourself easier. It wasn't until recently that someone on ##rust pointed out that with unambiguous syntax, you can more easily transform old code, too. So in some future where a piece of syntax changes, you can more easily write a tool that transforms old code into new code.
- thrtythreeforty 4y agoThe turbofish gets everyone's goat at some point but it teaches an important lesson: it is incredibly difficult to build a Rust-size grammar that is free of ambiguities! Modern parser tooling (e.g. tree-sitter) will at least yell at you when you specify an ambiguity.
- deleted 4y ago[deleted]
- Rochus 4y ago> The mistaken idea that “everything should be an object” doesn’t actually simplify anything in practice. We’re lying to ourselves, and in doing so, we actually makes the life of both language implementers and programmers more complicated. That gets to the point. But there is a lower bound of minimalism, below which the complexity increases again; I remember the time where a few academic ergonomists spread the idea that you should have only one knob in the user interface instead of many elements; the result was that you needed many more steps for each function and the operation was anything but intuitive. It's the same with a programming language: if it's designed too spartan, I have to write too much code that is always similar, which causes effort and obscures the real intention of the code. And if the syntax is too minimalistic, complexity is just moved to semantics or the standard library. So the art is to find the right balance, not just to omit.
- ebingdom 4y ago> It's the same with a programming language: if it's designed too spartan, I have to write too much code that is always similar, which causes effort and obscures the real intention of the code. I think Go is the perfect example of this. On paper, it's a simple language. But: - Not having sum types means it's awkward and unsafe to express concepts such as "X or Y". This is a big deal, because "Result or Error" is one of the most common ideas we have to deal with in programming. I think this tweet visually captures the awkwardness: https://twitter.com/GabriellaG439/status/1521860707444133888 https://twitter.com/GabriellaG439/status/1521860707444133888. Another place this shows up is pointers: in Go, since there is no way to represent "present or missing" at the type level, Go has to bake that possibility into the semantics of pointers. The billion dollar mistake. - Every type in Go has a "zero" value. On the surface, this seems simple: when you declare a variable, you get a predictable value without having to explicitly initialize it. But this prevents you from implementing abstract data types which are guaranteed to be constructed by a smart constructor that establishes all the relevant invariants. Now you always have to worry about this zero value, since it might not satisfy the invariants of your data structure (consider the simplest data structure with an invariant: a pointer which is non-null!). Also, you can easily forget to set a field in a struct, which means the zero value will show up in unexpected places (resulting in subtle bugs that might go undetected even at runtime). - Until recently, Go didn't have generics. Simpler, right? But that means if you want to build a reusable data type, you needed to either (a) make N copies of it, being careful to keep them in sync, with no help from the compiler, or (b) sacrifice type safety and represent data as interface{} (essentially a void* pointer), adding dangerous casts all over the place. Languages like Haskell and Rust are more complicated than Go. But once you've paid the upfront cost of learning them, common programming patterns actually become simpler. Of course, there's a flip side to this. Most languages have a lot of accidental complexity too, which isn't what my argument is about. So I almost hesitate to make this comment, fearing that it will be quoted out of context to justify adding badly designed features to programming languages.
- drpixie 4y agoMany languages seem to be treated like products ... must add new feature ... must announced new version ... as if the "owner" is worried about getting left behind. Mostly counterproductive. Many (most?) genuinely widely used languages are more-of-less static. C hasn't changed substantially in 20+ years. And many of us have worked in projects where a subset of the nominated language is mandated, or certain "features" banned - specifically to prevent the use of overly complex, poorly known, or misunderstood language features. I'm a fan of "if it works, don't make it worse."
- astine 4y agoI don't think I agree with that. Java isn't static. Python isn't static. C# isn't static. These are some of the heavy hitters in terms of total number of users. Stability is valuable, but popular languages still manage to add features to keep up with changing needs. Even C isn't %100 static.
- huqedato 4y agoRelevant article. When trying to port a project from C to Rust, I would take a look into Elixir instead of Rust. More clear/cleaner syntax, more minimalistic, functional, less verbose, mild learning curve. We did this successfully in our project: ported the entire back-end to Elixir from C++/Php, while initially we considered Python, Java and C#.
- jasfi 4y agoKeep in mind that you only have to use a subset of a language if you want to.
- yCombLinks 4y agoI personally believe in this too, and feel the same way about frameworks too. Other dev's have the "use every possible feature so this can never be removed" mindset which his bit me in the ass repeatedly.
- b3morales 4y agoBut everyone has their own subset that they want to use, so I still have to know and understand it all if I want to read other people's code. And moreso if I want to do anything with that code.
- hussainbilal 4y agoThis article went in a completely opposite direction I thought it would be going. Based on the title, I thought they were going to talk about how all operators should be expressed with 3 characters (i.e. `:=:`, `|=>`, etc.) or how all reserved words should be 4 character words.
- DeathArrow 4y agoMinimalism is good if it means not adding unneeded features or not adding things that don't go well together. Otherwise, it's not a great idea. Basic is a very minimalist language but good luck trying to do anything complex. Rust might be unnecessary complex and that is the other side of the coin.
- maxime_cb 4y agoLook at it a different way: maybe BASIC is good at exactly what it was intended to do, which is to provide a good intro to programming to kids and beginners. It was never intended to write enterprise-scale software, and that's ok. That's not the intended use case for BASIC, and it's fine that BASIC can't please everyone with every possible use case.
- sylware 4y agoyep, it seems rust is loosing its way like c++ (maybe it is already lost). And when you look at c23... same tracks. RISC-V quick!
- martincmartin 4y agoMany domains are inherently complex. If your programming language is simple, then the complexity will be in the code. Think Java's boilerplate, or having to re-implement hash tables every time in C because you can't abstract over data types. In a wood shop, you can do everything with a hammer and chisel. You can make a table leg with them. It'll take a long time and won't be super round. However, having a lathe makes it much faster and gives you a better end result. Also, it's been said that design patterns are just ways around missing language features. What one person considers language complexity, another seems as an essential abstraction.
- sdenton4 4y agoI think Go had a great observation that reading complexity != writing complexity for a language, and that many features which make writing coffee easier make the language harder to read. Go also made the fantastic decision to design in concurrency as a primitive... And then kinda for on the hill of generics. There's a lot to be said for choosing the right set of features, keeping the code readable as a first priority, and letting libraries handle the rest... Need a lathe? Import lathe!
- pif 4y ago> There's a lot to be said for ... There's nothing to add for what its creators stated: Go is meant for under-average programmers, not for professional software developers.
- fsociety 4y agoYou, software developer, are tasked with building a complex distributed system. Do you pick a high complexity language to build your high complexity system, or do you opt for a low complexity language do you can focus on the system? It depends on what benefits those language features have. More often than not, they do not provide benefit to your business. Plenty of professional systems are built in Go. This opinion that Go developers are subpar is silly rhetoric. It is not meant for everything, but for distributed systems it is great.
- hoseja 4y agoAuthor is complaining not all compilers satisfactorily support C++20 modules. But how is support for C17 features? Kernel only just switched to C11.
- pornel 4y agoC++ shat the bed for all languages :( Rust can't do anything without people fearing it's will inevitably end up like C++, or even just look at shallow syntactic similarities and conclude it's already just as bad. But really it's not. Rust has two+ kinds of strings on purpose because it has two kinds of ownership, not because it has a historical baggage. Really, C++'s featuritis and exponential complexity is unique to it. Pretty much every other language has survived decades of evolution without fucking up, and gracefully grew into something better. Java and C# are doing fine. JS and PHP have cleaned up a lot of mess. Even Ada and Fortran have been evolving for decades, and are fine. People learning Rust keep asking "but whyyyyy I have to write this syntax!?", and often they're surprised that the answer isn't "because BCPL on PDP-11…", but reasonable cases of bugs and ambiguities it avoids. Robust code at scale must avoid implicit behaviors, and good compiler suggestions depend on having redundancy in the syntax, so there's a limit to how much syntax sugar Rust can have to avoid creating gotchas.
- duped 4y ago> Rust can't do anything without people fearing it's will inevitably end up like C++, or even just look at shallow syntactic similarities and conclude it's already just as bad Frankly, that's an incredibly naive take. IME engineers that are confident to try out and work in multiple languages don't get scared off by syntax, rather the semantics. The issue with Rust in this regard to many experienced C/C++ developers is that the compiler forbids programs that are valid in C or C++ (for good reason, don't get me wrong), generic programming is highly encouraged and difficult to avoid, "unsafe" code is required yet significantly more difficult to write correctly than equivalent C and C++, and frankly, lifetimes are obnoxious. I say this as a massive Rust fan and shill. I don't think the syntax is that bad, it's certainly a lot, but I prefer it to something like Idris or Haskell that has a similarly expressive type system with noise-less syntax (that is significantly harder to read/understand compared to Rust). > C++'s featuritis and exponential complexity is unique to it Java is similar here, things like Project Loom for example are important but shift the paradigm for concurrency signficantly. To be totally honest, I dismiss almost all arguments towards languages based on syntax (I think there are some to be made, don't get me wrong). It usually comes from a very naive or inexperienced place. Syntax is important, but so is correctness and non-ambiguity.
- AzzieElbab 4y agoInterestingly, Scala is a minimal according to language specs but extremely complicated due to flexibility. People can write it like Erland, Haskell, Java, Ruby, or Python
- carapace 4y agoHear, hear! Wise words from the genius who created Turing Drawings. It's becoming more and more important to treat complexity as a kind of technical debt that has the potential at any moment to metastasize into eldritch horror. I've been playing with what you could call a minimalist programming language: Joy created by Manfred von Thun (who was a philosophy professor! See "A Conversation with Manfred von Thun" http://archive.vector.org.uk/art10000350 http://archive.vector.org.uk/art10000350 ) It combines features of Lisp and Forth, and I suspect it may be the simplest useful language. The syntax is enormously simple, and the semantics are likewise simple. It's easy to reason about functions and derive them in a mathematical way using simple algebra, so it's hard to introduce bugs. I recently found a very good 2017 talk by Jon Purdy describing concatinative programming and it's quirks and (potential) advantages: Stanford Seminar - "Concatenative Programming: From Ivory to Metal" https://www.youtube.com/watch?v=_IgqJr8jG8M https://www.youtube.com/watch?v=_IgqJr8jG8M Anyway, it's made me "allergic" to complexity. I tried Rust. Wrote the beginning of a Joy interpreter. I paused for a month and came back to it and it had become Greek to me, and I can't read Greek. :( Now part of that is just I 'm getting old, but a lot of it is the complexity of Rust. I don't want to pick on Rust though, complexity itself is the enemy (Rust is, if anything, an improvement on most of what has come before it, eh? I think only Ada can really be said to be Rust's peer?)
- avgcorrection 4y ago> Designing a programming language to be intentionally minimalistic is an idea that’s highly underrated in my opinion. Most modern programming languages adopt much more of a maximalist design approach. Rapidly adding new features is seen as a competitive edge over other programming languages. The general thinking seems to be that if your language doesn’t have feature X, then people will choose to use another language, or that adding more features is an easy way to show progress. This line of thinking is simplistic, and disregards many other key aspects that are necessary for a programming language to succeed and thrive, such as learnability, stability, tool support and performance. Not my impression at all. The author presents the design process itself as coming up with a list of features. What is much more sought after is to latch onto some of the following principles: 1. Turtles all the way down 2. Everything is an X 3. Uniformly treating [traditionaly different] things as "the same", like collapsing the value and type levels or letting you run code both at runtime and compile time You then try to implement the features that you need with one of the above starting points. For example, Zig apparently implements generics using number 3 (compile time code). In fact, the pinnacle of PL design to some people is to have very little in the way of built-in features and then let the users themselves implement whatever it is they need. Which I guess the Lisp family is the best at. The quoted paragraph seems like a caricature of the design process of a langauge. She says that this line of thinking "is simplistic". Indeed it is—non-believably so.
- carapace 4y agoI don't think she's presenting the "maximalist design approach" as a good thing, eh? > The quoted paragraph seems like a caricature of the design process of a langauge. (sic) It sounds like what's happening e.g. Python or JavaScript, the "design process" seems to be to add features, and then add features to your features so you can program while you program.
- avgcorrection 4y ago> I don't think she's presenting the "maximalist design approach" as a good thing, eh? The article is predicated on the assumption that this maximalist design is popular. But I have argued that it isn’t. A polemic needs an adversary. If not then it’s not a polemic and instead just a feel-good article about what most people agree on to begin with. Programming languages should be simple? And certainly not go out of its way to be complicated? Hmm, yes. yawn.
- cpurdy 4y agoMinimalism is usually in the eye of the beholder. There are only a few languages designed with minimalism explicitly in mind (Go is a good example), but even there (a language within which application developers readily accept doing the job normally assigned to the language and compiler) the demand for some minimal set of useful abstractions is forcing the language to grow over time. Let's be honest: Most complaints about bloat are actually complaints about stupid design decisions. But at the same time, it's admittedly difficult to learn something when it has a lot of one-off corner cases.
- hunterb123 4y agoLua is king of this
- roeles 4y agoOne of the most insightful things Alan Kay said in my opinion is that simplicity is the result of choosing a more complex building block. Intuitively I feel there's truth to this.
- ModernMech 4y ago> It breaks your intuition, and it constantly feels like the compiler is telling you that you’re writing code wrong. I had the same experience with Rust, and you know what? It was right. My intuition was in fact wrong, and the code the borrow checker complained about would have lead to memory access violations in other languages. Rust catches it at compile time so my program doesn't fall over at runtime. If you think you know better than the compiler, good on you, more power to you. But in my experience I've found that trusting the borrow checker has lead to rock solid stable code that is performant and never crashes during runtime with segfaults and other memory related symptoms of bad code.
- almostdeadguy 4y agoThis conversation almost always strikes me as a pointless exercise. We can't even agree on what it means to be "simple" or precisely define what it means to have "less features" in a programming language (or perhaps we can by saying complexity is anything more than what is provided by machine language, but we get no closer to an understanding of how much of this is necessary or when this is desirable). A programming language is an abstraction over machines and inevitably all languages introduce features to unburden the programmer from extraneous detail, toil, or precarity involved in orchestrating the operation of that machine. The author is correct that many "simple" languages like Brainfuck are actually very complex to use, but this strikes at the inherent feebleness of the premise that we can clearly define what we mean by a "simple" language (or at least any clarity on when the complexity tax is worthwhile or not worthwhile). Many programming language features are conditioned on a trade-off that having to think about X less in exchange for requiring knowledge of Y is a net benefit to the programmer. If we take the idea that simplicity means "less features" at face value, we throw out the notion of any high level language having the potential to be simple. The oft-cited Rich Hickey talk [0] I think gets _somewhat_ closer to vindicating the concept of simplicity being something we can talk about more objectively, but I'm still not convinced the concept is worth redeeming. Instead I would propose that languages should have a clear purpose and context in mind. Designing a language with clarity about the intended scale and pace of change in software that will be built in the language, the domain/category of software it is well adapted to build (i.e. embedded, web, OS, compilers, mathematics, mobile, servers, games, and so forth), and the nature of the teams and the public community it intends to support supersedes and encompasses whatever we want to call "simplicity" or "ease". What is easy, simple, helpful, etc. is incidental to how purposefully built a language is to a set of use cases. [0]: https://www.youtube.com/watch?v=LKtk3HCgTa8 https://www.youtube.com/watch?v=LKtk3HCgTa8