Hacker News Reader

Comment by hacker_9 | Hacker News Reader

"After learning a few more languages myself, I came to realize that they were all less diverse than I had anticipated. After some more study, I started appreciating some of the underlying models of computation and programming language theory that make most languages look like different versions of the same basic ideas."

Yep despite all these language wars, they all really are the same ~10 ideas shuffled around in a different priority queue (type safety over dynamic, camel case over snake case, AOT over interpreted etc).

I'm surprised the author advocates learning new languages after this insight, especially Rust and Go which are again just a reshuffle of the status quo (followed by the need to re-create everything in said language once again).

Instead of just re-learning the same ideas over and over under different names, how about do something actually productive in 2017...

View on HN

There's no way you can maintain that when you compare very different languages to one another, e.g. Scheme, APL, Haskell, Smalltalk, Go, Forth and Prolog. They're all such different ways of telling the computer to do something, that it isn't just the same 10 ideas being shuffled around.

Starting from a C# background:

Scheme - prioritized a 1:1 between syntax and the AST. Reshuffle the syntax, remove the explicit type system.

APL - prioritized arrays.

Haskell - prioritized FP. Also introduced primitives to make things possible with FP that you could do with OOP already (Monads etc).

Smalltalk - prioritized OOP.

Go - prioritized Concurrency.

Forth - prioritized Stack based.

Prolog - prioritized Stack based.

Really isn't that much insightful difference between these languages as you'd think. Not taking away from their history, but you gain nothing from learning them.

That's a really simplistic way of thinking about language differences. Saying that Smalltalk prioritized OOP is saying nothing about how Smalltalk is different in all sorts of ways from Java, or how Self and IO are different from both by doing away with classes, but closer to Smalltalk than C++. An important addition with Smalltalk and Self are the environments they live in, which are very different from most programming environments. Smalltalk was designed to be part of an image-based GUI, with modification of live objects, which includes the entire image, instead of text in files and folders, which are separate from whatever editor is being used. That's a huge difference (whether one prefers it or not).

And with APL, you leave it the not-so insignificant ability to use any character one wishes, which is again very different from most programming languages (whether one prefers it or not). It's not insignificant that an APL program looks nothing like a program in most mainstream programming languages.

I recommend an APL offspring to someone who wants to expand their horizons, rather than APL itself: K (or a variant thereof), or J. No special chars needed.

J used to be the only freely available, and with better documentation -- however, it is also a larger language. It seems that recently the K dialects (oK, klong, kuc, kerf, xxl) are plentiful, freely available and well documented.

It is also my experience that K is less frightening to most people - J uses e.g. curly braces independently as operators, which looks a-priori broken to most people (rather than just unintelligible like K does).

> Really isn't that much insightful difference between these languages as you'd think. Not taking away from their history, but you gain nothing from learning them.

you're missing out

Clojure - prioritized rich immutable data. I haven't found any other language that prioritizes open data sets: where a map has "a" and "b" but it could also have "c" and "d", if you only care about "a" and "b" it doesn't matter if the other data just tags along.

And I say "rich" data since other languages are pretty data-centric (scheme of course), but not any that prioritize immutable hash maps, sets, vectors, linked-lists, etc.

Reply on news.ycombinator.com