Dead

Good languages that died because at the time the people who agreed upon the languages were mad at each other for introducing their ``useless'' pet feature (of course your pet feature is never useless, just theother guy's) and denounced them for being too large:
+ ALGOL68
+ Common Lisp

over 900 symbols in Lisp?? No! That's too much!

And it's obviously not enough as there is a defacto standard extension library (Alexandria) providing more, and several other competitors propping up every now and then. ZetaLisp was much larger.

To put that into perspective, the Java library comes with 3977 classes and god knows how many symbols altogether.

You still get dumbfuck HN hipsters complaining about the massive size of Common Lisp today, when odds are whatever shit they're using has almost an order of magnitude more.

There are no good programming languages yet. They are all inept and unsuitable to most problem domains and differ only in the degree of their ineptitude.

Common Lisp is a bad language and you should feel bad about it.

Also lol @ developing anything in emacs.  Who has 38 megabytes of RAM to waste on a text editor?

Brainfuck

Brainfuck: 1 page

R5RS: 50 pages
R6RS: 167 pages (90 pages + 71 pages (libraries) + 6 pages (appendices))

Algol 68/FR: 142 pages
Algol 68/RR: 238 pages

ECMAScript 5.1: 258 pages

Haskell 2010: 329 pages

C99:TC3 (N1256): 552 pages
C11 (N1570): 701 pages

C++11 (N3242): 1334 pages

>>5
And they say Haskell is hard to learn, haha. Those same faggots who spend months learning the crazy dementia that is C++ call a language from the same family as Microsoft Excel "hard to learn". No fucking way!

>>5
Java SE + JVM 7: 1276 pages

>>5
Only the first 300 or so pages of the C++11 standard are the actual language, the rest is on the huge, and I mean really huge standard library.

>>7
That doesn't include the class library. The class library documentation would be at least another 1000 pages

>>5
Go 1.2: fits comfortably on a webpage, seems just a bit longer than Scheme R5RS.

>>10
Again, doesn't include the standard library.

How can you idiots possibly consider it equivalent to compare a language specification to a language specification + standard software library specification.

>>1
The problem with CL is that all of those 900+ symbols pollute the main namespace. In Java, Sepples, etc most of them are safely tucked away into packages or other namepaces.

>>12
LOL wut? No they don't.

There is no "main" namespace.

In fact, when you create a new package, unless you specify so explicitly, symbols from the package common-lisp are not used (inherited).

>>13
But can you import only say a 100 or 200 of those symbols into your package? No, it's either 900+ or none. I just want the math functions, not UPDATE-INSTANCE-FOR-DIFFERENT-CLASS for fuck's sake.

Thread is too old to post in! Make a new one.

>>14

You can import just one symbol.


CL-USER> (defpackage #:just-addition
           (:import-from #:common-lisp #:+))
#<PACKAGE "JUST-ADDITION">
CL-USER> (in-package #:just-addition)
#<COMMON-LISP:PACKAGE "JUST-ADDITION">
JUST-ADDITION> (+ 1 1)
2
JUST-ADDITION> (- 1 1)
; in: - 1
;     (JUST-ADDITION::- 1 1)
;
; caught COMMON-LISP:STYLE-WARNING:
;   undefined function: -
;
; compilation unit finished
;   Undefined function:
;     -
;   caught 1 STYLE-WARNING condition
; Evaluation aborted on #<UNDEFINED-FUNCTION - {1006AF7D83}>.

>>14
Yes.

Indeed some people abuse the fact that you can reorganize packages any which way e.g. recently some Japanese Lisper made a project (called CL21) which esentially paritions the common-lisp package and also wraps some functions around equivalent generics.

It's all very silly.

Algol 68 introduced the reference/pointer, array/list, structure/record, union/variant, and procedure/function that all modern languages have.
ref μ
[]μ
struct(μ₁ τ₁ … μ_n τ_n)
union(μ₁ … μ_n)
proc μ
proc(μ₁ … μ_n)μ

OOP is overrated. You don't even need classes when you have a record full of functions. That's all a JavaScript object is.