Hacker News Reader

Comment by goatlover | Hacker News Reader

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.

View on HN

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).

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.

> 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

Reply on news.ycombinator.com