17 ms·
I'm only just now starting to get on the Lisp bandwagon a bit... I've been working my way through Practical Common Lisp bit by bit (no pun intended) and I have
by mindcrime 11y ago
I'm only just now starting to get on the Lisp bandwagon a bit... I've been working my way through Practical Common Lisp bit by bit (no pun intended) and I have to say, I'm really liking this so far. I could see really getting into Lisp in a big way.
But... could one of you guys who knew the Symbolics machines help me out with something? What exactly made them so special, hardware wise? I mean, Lisp seems to run just fine on Linux on x64 hardware now. What advantage does one get from running Lisp on hardware which is custom tailored to it? Or would that even make sense nowadays IF something like the Symbolics Lisp Machines were still made?
- striking 11y agoThey were powerful desktop workstations (first of their kind!) They had up to 40 bits per instruction word in a tagged architecture, so a byte could be identified by object type without having the program say it outright. The processor was a stack machine that ran a bytecode compiled version of Lisp that did type checking and dispatching, in hardware, at runtime. Some of them had very powerful graphics boards that did all kinds of rendering. tl;dr: They had special hardware that aided in dynamic language processing, like 40-bit words and hardware dynamic dispatch. And it would not help you at all today because the most prohibitive part of the system is really the size of the CPU silicon wafer and its efficiency, and C is faster than Lisp and people are totally okay with writing code in it. EDIT: RE: getting into Lisp in a big way: https://web.archive.org/web/20080709051856/http://www.lambdassociates.org/Blog/bipolar.htm https://web.archive.org/web/20080709051856/http://www.lambda... tells you all you need to know. Specifically: "And the problem with Lisp? The answer is tailor made for the minds who program it. It is the koan of Lisp. "The answer is that there is no problem with Lisp, because Lisp is, like life, what you make of it." Your Lisp code (unless it's an emacs tool) will never work with anything or anyone else. You're invited to write everything from scratch, and doing so is easy; it's just difficult for anything you do to be used by or with anyone else's code. Lisp is so beautiful, and yet so dangerous.
- skissane 11y ago"Your Lisp code (unless it's an emacs tool) will never work with anything or anyone else. You're invited to write everything from scratch, and doing so is easy; it's just difficult for anything you do to be used by or with anyone else's code." - That might have been true once, but arguably isn't true any more, now that we have Clojure, ClojureScript, ClojureCLR, ABCL, Kawa, etc. And if you are willing to go for a multiprocess solution, there are numerous ways to integrate multiple languages over IPC or the network, from decidedly old-fashioned approaches like ONC RPC or CORBA, all the way through to the REST microservices of today, and there exist Lisp bindings for all of them.
- aidenn0 11y ago> Your Lisp code (unless it's an emacs tool) will never work with anything or anyone else. You're invited to write everything from scratch, and doing so is easy; it's just difficult for anything you do to be used by or with anyone else's code. Not really true these days, with the prolifiration of high-level-languages most libraries present a C interface which is no harder to bind to lisp than to other languages.
- yellowapple 11y ago> Your Lisp code (unless it's an emacs tool) will never work with anything or anyone else. You're invited to write everything from scratch, and doing so is easy; it's just difficult for anything you do to be used by or with anyone else's code. Since everyone else is jumping on this point, I might as well also point out that there are things like Chicken Scheme that actually transpile to C and are therefore compatible with it (and anything else that's compatible with C). > and C is faster than Lisp and people are totally okay with writing code in it. While C is indeed faster than Lisp (sometimes, at least; IIRC, some Common Lisp implementations like SBCL come within the same ballpark depending on the code being worked with), people are decreasingly comfortable with it as alternatives emerge and the cost of running a high-level language decreases (originally due to Moore's law, but nowadays also due to better-optimizing compilers and interpreters). I expect that we'll eventually hit a point where - much like how it's very difficult (if not borderline-impossible) to produce hand-written assembly that's faster than what a compiler will generate - it'll also be very difficult to write any sort of low-level code in a way that's faster than what a HLL compiler will spit out.
- lispm 11y ago> Your Lisp code (unless it's an emacs tool) will never work with anything or anyone else. I wonder how the Lisp I'm using got its Cocoa user interface. Oh, it has an Objective C bridge, so that it can create natively looking Mac applications...
- lispmachina 11y agoCCL is dead, move on :P
- merlincorey 11y agoI'm by no means a user of an actual Lisp Machine (would love to be though), but I can offer a few anecdotes I have picked up. Firstly, computers back then were so much slower than they are now that the speed boost from running native versus interpreted is definitely nothing to scoff at. Secondly, I now use StumpWM, a tiling window manager written in Common Lisp. This means I can connect to the lisp process that runs my window manager to inspect it, debug it, automate it, or make changes live. Now imagine you can do this with the entire machine! Thirdly, and finally, not everyone is aware of the etymology of "car" and "cdr": * car (short for "Contents of the Address part of Register number"), * cdr ("Contents of the Decrement part of Register number") * cpr ("Contents of the Prefix part of Register number") * ctr ("Contents of the Tag part of Register number") The original lisp implementation was on an IBM machine that had 36 bit words broken into 4 parts: the address register (15 bits), the decrement register (15 bits), the prefix (3 bits) and the tag (3 bits). Lisp started out very close to the machine, for being such a high level language!
- duncan_bayne 11y ago"Secondly, I now use StumpWM, a tiling window manager written in Common Lisp. This means I can connect to the lisp process that runs my window manager to inspect it, debug it, automate it, or make changes live. Now imagine you can do this with the entire machine!" A million times this! Such a machine, end-user-programmable from the ground up, is a real 'bicycle for the mind'.
- digi_owl 11y agoAnd would probably make just about any marketer and/or lawyer run screaming...
- duncan_bayne 11y agoIndeed. Which just means it's a doubly worthwhile project :) But seriously, this is the promise of computing we're talking about. It had to be put on hold for a while, because when you're dealing with a resource-constrained machine like an early 8-bit micro, IBM PC, or Mac, you're going to have to ship tightly optimised binaries and use non-native dev tools. So, given that no-one ships such a machine today, where are there priorities?
- agumonkey 11y agoHere's a talk from Kalman Reti using a Lisp Machine. http://www.youtube.com/watch?v=o4-YnLpLgtk http://www.youtube.com/watch?v=o4-YnLpLgtk pros: everything is lisp structure, no text serialization/deserialization to communicate between parts of the system. cons: see above.
- deckard1 11y agoA Lisp Machine today would be an anachronism. Hardware type tagging could be useful. But list efficiency and manipulation would likely be futile. Today, cache is king. Which means, linked lists are out. CAR/CDR? Let's not. The glory days were not that glorious. There are stories out there of runaway garbage collections, that grinded on for days. Today you get garbage collections in your web browser that would embarrass any Lisp Machine ever built.
- duncan_bayne 11y agoSure. I don't think anyone is arguing that we should fire up a Symbolics machine in 2015 and try to get work done on it. Rather, it's the spirit of the machines - inspectable and programmable from the ground up - that's worth preserving.
- lectrick 11y ago> inspectable and programmable from the ground up - that's worth preserving. This is what made me curious about the Smalltalk-based Squeak VM http://squeak.org/ http://squeak.org/. Its entire interface and stack was inspectable and manipulatable in real time. In practice it seemed a little buggy, though. If you installed Squeak programs too willy-nilly, pretty soon you'd get errors due to incompatibilities.
- digi_owl 11y agoAnd you can still have GC problem. Google ran into that with their Dalvik VM in Android.
- kazinator 11y ago> Which means, linked lists are out. CAR/CDR? Let's not. Data structures are dictated by the requirements of what you're doing, not the machine. Linked lists are out? The C middleware that runs everything is full of "struct foo { struct foo * next; int other_field ... }". Linked lists benefit from caching, like other kinds of data. > Today you get garbage collections in your web browser that would embarrass any Lisp Machine ever built. The garbage collection in your web browser is complete, utter garbage compared to what Lisp people were doing 30-40 years ago. Sorry! (I will add to this comment later; I have to go to Task Manager and kill the web browser.)
- vessenes 11y agoI think the simplest way to understand the zeitgeist is this quote: Giving up on assembly language was the apple in our Garden of Eden: Languages whose use squanders machine cycles are sinful. The LISP machine now permits LISP programmers to abandon bra and fig-leaf. -- Alan Perlis, Epigrams in Programming, ACM SIGPLAN Sept. 1982
- duncan_bayne 11y ago"Languages whose use squanders machine cycles are sinful." But not nearly as sinful as languages whose use squander human brain cycles.
- aidenn0 11y agoAs the availability of machine cycles has increased much faster than the human brain cycles has, it's reasonable to assume that this wasn't true if you go far back enough in time. I think it was Von Neumann didn't like assemblers because it was wasteful to use computers for such a mechanical process that cheap labor could do.
- duncan_bayne 11y agoYes, I agree entirely. I think if you went backwards in history you'd hit the point where the additional overhead in implementing a higher-level language would render the resultant system either unusable, or unusable for a class of problem that could be solved with a lower-level language. Edited: in fact, I started a project to implement a toy Lisp implementation on an 8-bit micro a few years ago. I'm almost at the point of giving up on the idea because it became quickly apparent that a less resource-hungry language would allow me to achieve more with the same hardware.
- aidenn0 11y agoForth is by far the most bang-for-the-buck on severely resource constrained machines. Lisp isn't CPU hungry, but it tends to be quite RAM heavy.
- RockyMcNuts 11y agoI don't think Lisp ran well if at all on early microprocessors like the 8-bit 8086. The Lisp community was, then, as now, committed to Lisp being the One True Way, and centered around the MIT AI lab. The PC revolution was happening, so naturally they built their own CPU, OS and workstations around Lisp. Half the MIT AI lab ended up going to Symbolics, and half to LMI. The West Coast hackers out of Berkeley and Stanford were more into C and Unix. Once the 68000 and the first Sun (especially), also Apollo, SGI workstations came out, they performed well at a broad range of tasks including even Lisp. C compiled software often outperformed similar software written in Lisp. And when volume ramped up (for 68000-based Macintosh as well) they had much better cost/performance compared to relatively low-volume Lisp machines. (like $30,000 for a decent Sun workstation vs. something like twice as much for a Symbolics) See Hackers, by Steven Levy, also some stuff in Wikipedia https://en.wikipedia.org/wiki/Lisp_Machines https://en.wikipedia.org/wiki/Lisp_Machines https://en.wikipedia.org/wiki/Symbolics https://en.wikipedia.org/wiki/Symbolics Had a summer job doing UI work on a Symbolics machine at MITRE, which was kind of like working in the future in summer of 1985... object oriented development, megapixel WIMP interface. I don't think Sun came close to that until UIM/X, Motif, PowerBuilder in early 90s, Visual C++, VB on PCs...like a 10-year head start. But python especially feels like the revenge of Scheme and Lisp in the sense of being the same sort of dynamic interpreted language and environment where code is data, all the data and code (including libraries) are very accessible and amenable to inspection and tweaking.
- Taniwha 11y agoSun was just spinning up - but remember that first Mac (3/4M pixel WIMP interface) had become available the year before for $2400 (and I was making a living in '84/85 porting Unix to 68ks as fast as we could, every man and their dog had built a workstation in their garage)
- pdw 11y agoThe early Macs had tiny displays, something like 512x342. The first Macs with a resolution of 1024x768 (¾ megapixel) wouldn't appear until the 90s.
- 11y ago
- dzamo_norton 11y agoAdding to your question: who would accept a computer that only executed programs written in a single language? I remember people talking about CPUs that would run Java bytecode natively back when the Java hype cycle was near its peak, say 12-15 years ago. Never saw one on the shelf though, I guess once the JIT compiler started working well people lost interest.
- varjag 11y agoMost of today's computers only execute programs written in a single language: its instruction set. The original Symbolics architecture ran some form of Lisp-firendly but not really Lisp instruction set. IIRC there were compilers from other languages targeting it too.
- draven 11y agoThere used to be things like this: https://en.wikipedia.org/wiki/Jazelle https://en.wikipedia.org/wiki/Jazelle
- avian 11y agoAmazon Kindle 3 has an ARM CPU that claims to support this, so this has been in production as recently as 2010. Not sure if it's actually used with the stock firmware.
- rjsw 11y agoModern ARM CPUs report that they support Jazelle but will just trap to an exception handler for every JVM bytecode. A Java CPU that works in a similar way to a Lisp Machine is JOP [1], it has microcode to implement the user-visible instructions. [1] http://www.jopdesign.com/ http://www.jopdesign.com/
- pjmlp 11y agoIt was the whole experience of having the full OS stack written in the same language. Also having the REPL act as shell, which meant any Lisp library on the system, or running application was exposed to the shell and could be manipulated. Imagine having something like IPython or Swift Playgrounds as your OS shell. Also the power of having an expressive power of language like Lisp for both systems and business application programming.