Hacker News Reader

Comment by hardwaregeek | Hacker News Reader

I was thinking recently about why I find programming languages so interesting. The answer I came up with was that programming languages allow you to create your own reality. You get to define how things work in this reality. Want functions to be values that can be arguments and return values? Sure! Want a lot of crazy symbols to do complicated math? Go for it! Want everything to be dynamic? Why not.

The caveat that comes with this description is that sometimes people shouldn't create their own reality. Whether it's making decisions that ultimately lead to really screwy universes or just not being prepared to deal with the power that comes with changing the very fabric of reality, some people will not mesh well with LOP. And there's nothing wrong with that.

View on HN

The problem is that people often create languages that are basically the same as existing languages; no new concepts. New languages are usually a grab-bag of features found in C, Java, Lisp and/or Haskell.

At the same time, even a language that is just a combination of features from those languages can strike a different balance between the concepts and it's the balance that defines the languages.

There's a quote on the whiteboard in my lab that is (perhaps falsely) attributed to Larry Wall that says something like:

> Programming languages are distinguished not by what they make possible, but by what they make easy.

Practically all programming languages are computationally equivalent. The design of a new language simply seeks to answer the question: what should be easy for the programmer? Various languages are just different answers to this question.

This seems unsatisfying. Most of the modern languages are choosing pretty much the same sets of features. I've been using them for years (decades?), and I couldn't tell you significant differences between most of these languages.

There's maybe 3 major islands of languages today. Within each island, they make essentially the same things easy.

The answer to a question like "Python or Ruby?", "C# or Java?", or "Rust or Go or C++?" mostly boils down to historical accident: what system did the original designer pick, which usually means which one just happened to have a good library for the primary goal of the first prototype.

I'd add some caveats to GP's comment, but I think it's mostly spot on.

>"Rust or Go or C++?"

Does one of these make memory problems easier to avoid?

>"Python or Ruby?"

One of these prioritises having a single way to do most tasks, while the other prioritises programmer expressiveness (simple example: "unless" is absent in Python). Thus one is easier to onboard newbies with and have them relatively quickly be able to read the code in their ecosystem, while the other allows skilled programmers to convey semantics more efficiently.

I'll admit being mostly ignorant about the differences between Java and C#, but at least in general the languages you contrasted do make different things easier.

Edit: grammar.

>the differences between Java and C#

Not much.

Are you primarily targeting Microsoft platforms? If so, then C# might have the edge. Otherwise, you might prefer Java.

> One of these prioritises having a single way to do most tasks, while the other prioritises programmer expressiveness

And yet, whatever they claim to prioritize, they aren't particularly different on those fronts.

OTOH, they have radically different features even if both are dynamic multiparadigm languages, though it's true that decisions between languages often turn on ecosystem rather than language features independent of how different the language features are, and that's also true of Ruby vs. Python.

My guess is that you’re seeing popularity based selection bias at work: languages with more common features are easier to understand and gain popularity faster than truly bizarre and unique languages which are confusing to newcomers. These popular languages end up being the ones you see every day.

I bet a true random sample of programming languages would be a lot weirder.

I'd love to see some examples.

///

Find the video '50 in 50' by Steele and Gabriel.

50 programming languages of the last 50 years, illustrated in 50 minutes. It includes all the popular languages, but also covers some truly weird ones.

I feel like programming languages that wants to be used in production have a novelty budget. Rust does a great job of managing this, for instance.

Haskell is an interesting case because it is a fairly simple language by default (hm type system) with laziness as big innovation. But it also lets you play with experimental features via language extensions. Some work out great, others like implicit nested data parallelism get axed eventually.

> New languages are usually a grab-bag of features found in C, Java, Lisp and/or Haskell.

With different predecessors, that's also true of at least C and Java on that list.

OTOH, the particular "combination* of features in the grab bag can be quite significant in practice, even if none of three features are new individually.

I think the ability to conjure up things out of nothing, that have no constraints derived from the physical world, is a lot of the appeal of computer-based activites such as programming or 3d graphics in the first place.

This is exactly why I got into programming, to make my own realities in then-current 8-bit games. I've since switched to this more abstract endeavour which gives the same satisfaction without realizing this being the reason. I'm also holding out for a VR title that can showcase this aspect rather than a horror in SciFi backdrop.

Some demos/press copies of Dreams VR recently showed off some compelling creative storytelling tools

- https://www.giantbomb.com/shows/dreams-01302019/2970-18741

- http://dreams.mediamolecule.com/

It looks like one will have to write a whole lot of languages to be reasonably good at language oriented programming.

Remember the first couple of programs you wrote? I bet they were all quite similar.

A pretty great example of "microworlds" from Seymour Papert'a "Mindstorms," which you would enjoy!

Yeah, that's what I like about languages like Lisp and to a lesser extent Python and, conversely, why I dislike languages like Go.

uh..What is? (what you like about them)

Go has quite its own reality.

Structural typing, no generics, interface oriented.

Sure, Java has interfaces, C doesn't have generics and TypeScript is also structurally typed, but I guess nominal typing, generics, and OOP is what most people who like static typing in the first place prefer.

The worst is when people do use Go to make their own reality. It's not meant for that and it's never pretty.

Reply on news.ycombinator.com