Hacker News Reader

Comment by lacker | Hacker News Reader

The Algol, Smalltalk, Pascal, and early Scheme languages were prized for being small and beautiful.

Those languages are also not very popular at all today. Perhaps "small and beautiful" are not the right metrics to optimize programming languages for.

In many ways, keeping the core JavaScript language small has led to the JavaScript ecosystem being too large and sprawling. For example, look at module importing, something which is a fairly normal part of most programming languages. It still works in a completely different way in Node.js and in browsers. I think if there had been a standard way to handle JavaScript imports years ago, the practical experience of working in JavaScript would be simpler today.

View on HN

Programming languages can be categorized in a number of ways: imperative, applicative, logic-based, problem-oriented, etc. But they all seem to be either an “agglutination of features” or a “crystallization of style.” COBOL, PL/1, Ada, etc., belong to the first kind; LISP, APL– and Smalltalk–are the second kind. It is probably not an accident that the agglutinative languages all seem to have been instigated by committees, and the crystallization languages by a single person.

Alan Kay's "The Early History of Smalltalk:"

http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html

> Those languages are also not very popular at all today. Perhaps "small and beautiful" are not the right metrics to optimize programming languages for.

Perhaps popularity isn't.

I think that popularity is probably indicative of other qualities of a language, and at the very least, I think being popular is a good feature in itself (in terms of getting support, libraries, documentation etc)

Platforms are products that sell languages, not the other way around.

So being popular just means having the luck to be on a platform that is doing well.

Usually most programming languages fade way when that platform stops being relevant, as history has proven a couple of times.

I quite strongly disagree. My favourite languages, Scheme, C, Go, share precisely the "small and focused" philosophy, and its a big reason why I like them so much. Your point about javascript is not very strong either, I imagine the real reason is its origins as a browser-embedded language meant that the same style of imports in Node.js were not feasible. Even if this is not true, I would then shift the blame to the implementor of Node.

Scheme in particular deserves so much more attention, it is so capable and it is a joy to write.

C appears small.

I doubt even veteran C developers know by heart its 200 UB documented use cases on ISO C, or the specificalities of any C compiler other than the one they daily use, and which features of it are actually part of ISO C.

Unless they happen to do ISO work all day long.

Pascal also cheated on size, by omitting some facilities that were almost indispensable for practical programs, leading pretty much all implementations do add them in incompatible ways.

The first version yes, ISO Extended Pascal fixed that, however by then everyone was mostly focused on being compatible with Turbo Pascal.

> Those languages are also not very popular at all today.

But yet, C (arguably 'current algol') and Python (arguably 'current scheme') are..

yes: python is verry loosely like scheme, this is meant in the sense of a 'dynamic loosely typed language you can interact with in a repl'

> "dynamic loosely typed"

Both Python and Scheme are dynamic but strongly typed.

i'm going to disagree here.

yes, they have strong core types, but there is nothing preventing you calling some function with completely invalid arguments..

even within the 'interpreted fp' world, there are better examples (e.g. ML family)

I think you may be missing some terminology here. Strong typing is about whether entities have definite types and resist type coercion. Ad-hoc typing in dynamic languages can make this hard to see, but it's still there. What would prevent you from calling a function with invalid arguments would be static typing, which Python and Scheme do not have.

Lua is a far better counter-example as a successful small and (conceptually) beautiful language.

yes, probably so. was going for 'popularity' here

the significant difference between python and scheme here is that python is not small.

but then, scheme is heading in the same direction if you look at the latest standards development

Depends on what you mean by "latest". R6RS is arguably huge. That's why they decided to split R7RS in two, a small core which is done and a huge version which, ironically, is still in the making.

R7RS is still in the making, not because it is bigger, rather due to politics that many don't agree with it ever happening.

The small core exists, because that was the only subset their were willing to agree on.

right, it may not happen, but at least some people want to add stuff to scheme that will make it larger, to eventually reach the point where it no longer can be called a small language.

i don't know if/when that point will be reached. my comment was hinting at the potential for scheme to become larger.

Reply on news.ycombinator.com