Hacker News Reader

Hacker News

Comment by acqq | Hacker News Reader

Parent Full thread

acqq

Actually he did build the whole basis of GNU:

Lisp:

http://en.wikipedia.org/wiki/Emacs_Lisp

"Richard Stallman chose Lisp as the extension language for his rewrite of Emacs"

and

C compiler:

http://en.wikipedia.org/wiki/GNU_Compiler_Collection

"When Tanenbaum told him that while the Free University was free, the compiler was not, Stallman decided to write his own."

View on HN

And http://www.gnu.org/s/guile/ was supposed to be the scripting language of the whole system[1]. It's getting back into light recently.

[1] http://en.wikipedia.org/wiki/GNU_Guile#History

My comment is that he should have built more of it in Lisp since it's a better language. First he needed a better Lisp (ie. high-performance Lisp). Then he would have had a better foundation. Wouldn't we be better off with hundreds of millions of lines of free software in Lisp rather than C?

You are probably not aware of the details of what he did with Emacs and GCC. The short answer is: it was possible to implement reasonably effective Lisp in Emacs, but it was impossible to replace the most of Unix infrastructure in it. Therefore the GCC was necessary.

It's not about the "theoretical possibilities" it's about the practical limitations.

I can't refer to you to any single resource regarding the limitations of any Lisp for implementing the free-source replacement of Unix, but if you investigate how the Lisp in Emacs was actually implemented you can get the picture. Provided you have enough basic knowledge about the low level aspects of the CPUs, compilers and interpreters and also the limitations of all the hardware before the most modern CPUs. Even today, what's "good enough" on the desktop can be "too much demanded" from the lower power systems. But the lower power systems of today are also much more advanced than what we had for decades during which GNU project grew.

GCC 1.0 was released in 1987. The 2000 USD computer had less than 1 MB of RAM then.

Yes, I am aware. I didn't say that GCC wasn't necessary. Performance does matter. However, if he had a better Lisp then as Moore's Law advanced over the past 3 decades, Lisp could have become more common. Emacs Lisp is slow and it's also not a standard like Common Lisp or Scheme.

We'd all agree C isn't as necessary today. Lots of great stuff is done in Ruby, Python, JavaScript, Node.js, Clojure, etc. Developers are building editors in browsers (atom.io) and Microsoft used atom with 200k of Typescript in their new cross-platform tools.

It doesn't matter what was before 3 decades. You have the environment that exists now. You can use better Lisp, if it's good enough now, for what you need to do. For the resource limited and performance critical stuff I still use C and a lot of actual environments still need C-level performance and the resource use patterns.

And all this is not because of what RMS did or didn't do. He did great things, and I don't agree that anybody can claim that he could have done something differently given the real constrains he had.

There are loads of languages like that, I don't think that you can blame rms for this. For example, the MLs are currently kinda hot, ocaml especially, and have been around for donkey's years; but in the early 1990s they were very slow.

Lots of the applications written in ML are barely viable; the only reason they're performant now is due to Moore's law.

$1000 computer had 1 MB of RAM in 1987. $699 for Amiga 500 (had 512 kB) and $159 for A501 512kB memory expansion.

Maybe I should have said "a PC" instead of "a computer." As in, something that actually had a hard disk. Did GNU software run on Amiga 500? Had it been a good decision to target it instead of the PC-compatibles? I don't think so.

An Atari ST/Mega ST could have a hard disk too.

I ran Franz Lisp on my Atari ST which included a native compiler.

I don't doubt that. The topic was the platform suitable for GNU. Neither Atari nor Amiga had been a good choice then.

Amiga 500 had A590 among others, 20 MB hard disk. Lattice C was the compiler used for Amiga.

Sorry, I was unclear. Franz Lisp compiled to 68k binaries, there was also Cambridge Lisp for the Amiga.

I just wanted to point out that this class of computers was a valid target for a good Lisp system.

Some of the most performant games ever created were written in Lisp or a variant of it.

http://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp

Million polygon levels running at 60fps when the majority of games on that system had 1-2 orders of magnitude less geometry and ran at 30fps and were written in C/C++

I'm NOT saying therefore RMS should have used lisp instead of C but I am suggesting that any perf objections or memory objections are mostly not factual. It's perfectly possible to make a performant non-memory hungry lisp.

Written using Allegro Common Lisp, a "commercial implementation of the Common Lisp programming language developed by Franz Inc." Which was related to the Macsyma and going proprietary, and "the closing of the MIT Lisp and Macsyma efforts was a key reason Richard Stallman decided to form the Free Software Foundation."

https://www.ma.utexas.edu/pipermail/maxima/2001/001119.html

RMS: fighting proprietary software for more than 3 decades.

Also interesting: the game company "transitioned to C++ for future projects" according to Wikipedia.

Strange.

Allegro CL appeared long AFTER Stallman decided to form the FSF...

And apparently is still a commercial (non-free) implementation.

> Also interesting: the game company "transitioned to C++ for future projects" according to Wikipedia.

They did after Sony bought them, to improve code sharing with other Sony game developers.

After they found out that this was not the case, they have been using Scheme (a dialect of Lisp) again in their development.

http://www.naughtydog.com/docs/Naughty-Dog-GDC08-Adventures-...

http://de.slideshare.net/naughty_dog/statebased-scripting-in...

Thanks for the slides (the second link)! What I can conclude is that only the game scripting was ever based on Lisp, never the whole engine? This sounds much less impressive and makes the achieved FPS claims almost irelevant.

And there were some other opinions on usefulness of such approach:

http://en.wikipedia.org/wiki/QuakeC

"Despite its advantages, the concept of implementing the game logic in a separate scripting language and writing an interpreter for it was soon dropped (even by John Carmack who had implemented this concept) because of the overall inflexibility of an interpreted language,[3]"

On another side, there are a some games which used Lua for scripting:

http://en.wikipedia.org/wiki/Category:Lua-scripted_video_gam...

Jak & Daxter the whole engine was lisp based.

As for the arguments that you can't interface with others because they don't know lisp and there aren't lots of libraries that's true of every language at some point in their lifecycle. There might be other reasons that's never happened for lisp or it might just be that no one has successfully made a concerted effort to get it there?

Maybe one of the LLVM based lisps would help a transition or at least let people try lisp on part of their C/C++ code base

> Jak & Daxter the whole engine was lisp based.

Only when "the whole" is defined to mean "the object scripting."

http://www.psxextreme.com/feature/45.html

"The final game engine has about nine different renderers, each is optimized for its specific task."

http://c2.com/cgi/wiki?LispInJakAndDaxter

"GOOL was used to control objects in the game"

Jak II had apparently the most of GOAL:

http://lemonodor.com/archives/000610.html

"Of the 1.2 million lines of code, roughly 900,000 lines are written in GOAL."

Still that leaves 300,000 lines which were certainly the most low-level and performance-sensitive ones.

The 900,000 lines aren't exactly "the Lisp," but that custom language, developed using the commercial Lisp, but I admit it's certainly an engineering achievement.

Those games were written in C or C++ (and probably some assembly) and scripted in Lisp.

No they weren't. There was zero C/C++. Source Me. I worked on them

You mean even the renderer was written in Lisp? Didn't you have any issues with garbage collection?

Stallman likely worked in the LISP your describing. He was a researched at MIT's AI lab. Their the LISP machines they went on to produce were actually a hybrid natively assembled OOP LISP, aimed at solving a lot of the low level issues you'll run into writing a kernel/system tools in LISP. I haven't worked in this language, I've just seen it referenced in a large number of places.

As he ultimately decided to not go this direction, I'm going to assume he considered it more of a dead end.

He says his favorite languages are lisp and C.

Which would mean he likes C.

How then is it doing the world a favor to write less of one of his favorite languages?

The grandparent wrote "great Lisp". Presumably the poster doesn't think that ELisp is that.

Reply on news.ycombinator.com