4 ms·

Symbolics stuff not just worked, it worked remarkably well on the very modest hardware and solved real word problems. For an example of unimaginable by "modern

Symbolics stuff not just worked, it worked remarkably well on the very modest hardware and solved real word problems. For an example of unimaginable by "modern standards" quality, go ahead and take a look at the Common Lisp documentation produced by Symbolics (the art of writing, "motorcycle maintenance" kind of clarity and conscience) which is buried somewhere inside bitsavers and take a look at the sources of Open Genera 2.0, the whole OS, which was available of dynamic modification and extension by the programmer, which could be found in a torrent search, and then go to the rosettacode website and look at every single page too see what a fucking crap is the language you are using to get shit done in exchange for a paycheck. It is worst in any possible way - verbosity, clumsiness, clutter, cryptic syntax, you name it. This is actually not interesting notion. Everyone with a bit of brains could visit rosettacode. The interesting questions are why it is so that the world is dominated by Java. Pages and pages were written about what's wrong with Java and why it is so popular. One sentence summary could go like this "a sandbox for crowds of packers to get shit done, agressively marketed to them via "you don't have to understand" memes by corporations to make big money". It spread like a virus due to bandwagon and peer effects and catchy memes like "write once" or "millions of man hours". Ok, use it, enjoy yourself, but, please, do not touch so rare and really wonderful things which you unable to comprehend.

brazzy 13y ago
Yeah, I guess you'll keep telling yourself that because it makes you happy and remain unable to comprehend just how wrong you are...
- dschiptsov 13y ago
  Why, yes, reading Symbolics CL docs or David Moon's "language for oldtimers" makes me happy, like any other decent reading.
- ithkuil 13y ago
  Neither you nor OP are wrong. It's possible, and common, to have practical tools that suck hard. It's also true that the more people use a tool (and for longer time), the more ways it will be found to suck (and Lisp has been around for quite a while (and used by quite a few people too (probably used by less people than Java) and (indeed) it managed to spawn quite a few heated reactions (to it's salient characteristics)))
outworlder 13y ago
Everything in the Java language is done so as to prevent clueless people from messing up too much. It is an useful goal, but it impairs creativity and productivity. Complex concepts are either not implemented or forbidden outright. This is even in contrast to its closest competitor, which is C#. The latter has evolved a lot since its creation, while in the Java world lambdas are the hot new thing. But hey, you can hire cheap labour and they will be prevented from messing up too much, so corporations like it.
- dschiptsov 13y ago
  Yes, this is what sold it to managers.)
- __--__ 13y ago
  For corporations, consistant work is often more desirable than exceptional work. Amassing thousands of lines of code that only exceptional programmers can use, understand and modify is a liability, not an asset, no matter how efficient it is.
  - mindslight 13y ago
    Which is a quality of a fundamentally broken organizational system that measures power in (and therefore optimizes for) number of people controlled, as well as the government-directed economy that underwrites it.
    - __--__ 13y ago
      tl;dr: there's a reason most startups prefer javascript to smalltalk. Which is a quality of a fundamentally broken organizational system No, it's a quality of a robust organizational system. Let's take a program that parses html as an example. What would you think of an html parser that only works well with high quality, strictly structured html and breaks under poorly formatted html? You would call it a fragile, broken system. But a parser that deals equally well with low quality html would be a well thought out, robust system. And here's the key to the point I was making: the robust system could be relied upon to do its job consistently even under less than ideal conditions. A system that requires exceptional engineers to maintain it is a huge source of risk for any company. If your current exceptional engineer leaves for whatever reason, you have to find another one. If the reason your engineer left is your company is suddenly facing insolvency thanks to a nasty patent dispute, all you may be able to afford to hire is a college grad to maintain what you've already got.
BruceM 13y ago
Running Open Genera in a VM is quite an eye-opening experience. Such a very different vision of computing and what is possible.
- pjmlp 13y ago
  Yes, this is why I sayed in another thread here in HN that UNIX made the industry do a left turn. Lisp Machines I only know through videos and old papers. But I do have experience with Smalltalk during my CS degree, before Java was a thing. Smalltalk is by no means Lisp, but shares a few ideas. If those systems had become mainstream, computing would probably be like Bret Victor discusses on his "Future of Programming" talk. Instead we have developers still using systems as if UNIX had been released last year.
  - lispm 13y ago
    At the European Common Lisp Meeting later this year in Berlin/Germany I'm probably demoing a real hardware Symbolics Lisp Machine and its OS...
    - pjmlp 13y ago
      Sounds tempting, as I live in Germany. Thanks for the hint.
angersock 13y ago
Symbolics stuff not just worked, it worked remarkably well on the very modest hardware and solved real word problems. Sadly, sadly, that's not enough. Oftentimes, that doesn't even matter.
mwfunk 13y ago
This comment is to programming language analysis what Pitchfork reviews are to music analysis- lots of tribalism, lots of emotion, lots of apparently non-self-aware hyperbole, and entertaining as long as what the reader is looking for is entertainment and not actual analysis of anything. If your goal as a programmer is simply to have fun, then carry on, but if your goal is to have a handle on whatever scraps of objective truth are out there (or even just to solve concrete problems) then you may want to devote at least some tiny part of your time to trying to see things from other people's perspectives. Those other people may not necessarily be correct about anything, but when it comes to engineering even the faintest wisp of objective truth is worth a lot more than strongly expressed emotions, no matter how poetic it may seem to you.
- dschiptsov 13y ago
  Let's say that Lisp is very different because it was based on a "good ideas", well researched in "good places" like MIT AI and CS labs (no punks could get there). It has something to do with shoulders of Titans. The set of selected "good ideas" is intentionally keept small and well-balanced. Let's take a walk. The "layers of DSLs" metaphor mimics as close as possible the way our mind uses a language, which we call "verbal", or "logical" mind, as opposed to "non-verbal, ancient, emotional" mind, which is based on evolved reflexes, captured by genes (Sorry!). We are using symbols to refer to inner representations (concepts) we have in our minds. so "everything is a symbol" (just a reference to a "storage") is a "good idea". When we're talking about some specific context (situation, or "domain") we tend to use some reduced, appropriate set of words (symbols) related to it, along with usual "glue". This what we call Domain Specific Language, or a Slang, if you wish. This is also a "good idea", groups has slangs. Layered structure is, in some sense, what the Nature is. Atoms, molecules, proteins, tissues,, organs, systems, brain, body, you see. So, layers of data is a good idea, but layers of DSLs is even better one. It not only mimics how the world is, but how we should structure our programs. Neither the language nor its layers are set in stone, they could be transformed, extended, adapted using the very same mechanism which underlies it. Iterative looping constructs, for example, were build out of macros, and the Loop DSL is the most striking example of how a language could be expended with itself as a Meta-language. Some "good people", like R. Gabriel, have argued that we need more complex control constructs (special forms) as long as we are trying to write complex programs (language should be adequate to the domain), so, the ability do define new special forms as we go, without breaking everything, is a "good idea". This is, btw, the idea behind the recursive bottom-up process of software development, popularized by SICP and championed by pg and rtm. Language should evolve together with our understanding of the problem domain. Structures is also a DSL. This gives us the way to structure our data (everything is an expression in a Lisp, everything could be evaluated, this is another very "good idea") to mimic or represent more conveniently the objects of real world. Structures could be nested, getters and setters were created automatically, but could be redefined, etc. So, by extending the language with new, appropriate constructs (by defining new special forms) we could improve our way of modeling the reality and create better "inner representations" for the concepts we made (captured)? Seems like a "good idea". But wait, because everything is an expression (a Lisp form) which could be evaluated, why not just put code blocks (expressions) into the same structures? Thus we have "data structures" which captures not just characteristics (state) but also behavior of real world "objects". To capture the behavior we need the notion of "protocols", which is just a named set of generic functions. So we have defprotocol which, essentially, creates a structure and binds names (symbols) to procedures (expressions) which consists of Lisp forms. Thus we got MOP implemented, which is the basis of CLOS. I forgot to mention, that since everything is a symbol (reference) we could combine "objects" into lists and other aggregates, map them, reduce them - the whole set of layers of language "below" are available. This doesn't mean that this is the only way to program, this is just one of the possible programming paradigms. What is really matter is that we could, by using the very same means of combination and abstraction "import" any other paradigm we wish. And everything so uniform and concise that it could be easily traced back to "conses". btw, this is not a "strict", "rigid", "set in stone" language (it is a nonsense to try to "fix" a language, it contradicts with the its nature). We have reasonable, "evolved" defaults, such as Lexical scoping for variables, but we could have Dynamic scoped ones if we wish. Thus, it is possible to extend the language with "non-local exit" control structures, which is your fucking Exceptions. Immutablity has also reasonable defaults. List and mapping functions are always producing a new copy of a list, leaving original ones unaltered, while their "destructive" equivalents were segregated by following an explicit calling convention (Scheme is famous for this). Evaluation strategies could also be explicitly selected, so lazy lists or streams could be defined using the very same conses and macros and list notation. Being a small language (after all the transformations - macro-expansions, rewriting rules, inlining has been done) it could be efficiently compiled (using a compiler written in itself) diretly into Machine code, which runs on more plathorms than fucking JVM. This is what some people are considered as a work of a fine art, and called "programmable programming language". But this is only a half of the story. There were machines (a hardware FSM if you wish) which was able to run the Lisp code efficiently. But this is another story.
AnimalMuppet 13y ago
If you build a better programming language, and the world does not beat a path to your door (even after 50 years), that's because the world is too stupid to appreciate the genius of your beautiful language? Right. Grow up, kid. Lisp has its virtues, but the Lisp evangelists/cheerleaders/fanboys would be more effective at converting the rest of us if they quit assuming that anyone who disagreed with them was too stupid to see the obvious virtues of their wonderful language. And don't say that you don't care whether others like your language. You care whether others like it enough for businesses like Symbolics to survive, so that you don't have to visit bitsavers to see this stuff that you love so much.
stonemetal 13y ago
the whole OS, which was available of dynamic modification and extension by the programmer, Sounds like a nightmare, writing code for an OS where every chucklehead with a keyboard has modified it just because they can. Rather sounds like the curse of the gifted[1] writ large. Sure it was cooler and had neat features but couldn't reliably deliver over the long term. [1] https://news.ycombinator.com/item?id=7219872 https://news.ycombinator.com/item?id=7219872

brazzy 13y ago

Yeah, I guess you'll keep telling yourself that because it makes you happy and remain unable to comprehend just how wrong you are...

dschiptsov 13y ago
Why, yes, reading Symbolics CL docs or David Moon's "language for oldtimers" makes me happy, like any other decent reading.
ithkuil 13y ago
Neither you nor OP are wrong. It's possible, and common, to have practical tools that suck hard. It's also true that the more people use a tool (and for longer time), the more ways it will be found to suck (and Lisp has been around for quite a while (and used by quite a few people too (probably used by less people than Java) and (indeed) it managed to spawn quite a few heated reactions (to it's salient characteristics)))

outworlder 13y ago

Everything in the Java language is done so as to prevent clueless people from messing up too much. It is an useful goal, but it impairs creativity and productivity. Complex concepts are either not implemented or forbidden outright. This is even in contrast to its closest competitor, which is C#. The latter has evolved a lot since its creation, while in the Java world lambdas are the hot new thing. But hey, you can hire cheap labour and they will be prevented from messing up too much, so corporations like it.

dschiptsov 13y ago
Yes, this is what sold it to managers.)
__--__ 13y ago
For corporations, consistant work is often more desirable than exceptional work. Amassing thousands of lines of code that only exceptional programmers can use, understand and modify is a liability, not an asset, no matter how efficient it is.
- mindslight 13y ago
  Which is a quality of a fundamentally broken organizational system that measures power in (and therefore optimizes for) number of people controlled, as well as the government-directed economy that underwrites it.
  - __--__ 13y ago
    tl;dr: there's a reason most startups prefer javascript to smalltalk. Which is a quality of a fundamentally broken organizational system No, it's a quality of a robust organizational system. Let's take a program that parses html as an example. What would you think of an html parser that only works well with high quality, strictly structured html and breaks under poorly formatted html? You would call it a fragile, broken system. But a parser that deals equally well with low quality html would be a well thought out, robust system. And here's the key to the point I was making: the robust system could be relied upon to do its job consistently even under less than ideal conditions. A system that requires exceptional engineers to maintain it is a huge source of risk for any company. If your current exceptional engineer leaves for whatever reason, you have to find another one. If the reason your engineer left is your company is suddenly facing insolvency thanks to a nasty patent dispute, all you may be able to afford to hire is a college grad to maintain what you've already got.

BruceM 13y ago

Running Open Genera in a VM is quite an eye-opening experience. Such a very different vision of computing and what is possible.

pjmlp 13y ago
Yes, this is why I sayed in another thread here in HN that UNIX made the industry do a left turn. Lisp Machines I only know through videos and old papers. But I do have experience with Smalltalk during my CS degree, before Java was a thing. Smalltalk is by no means Lisp, but shares a few ideas. If those systems had become mainstream, computing would probably be like Bret Victor discusses on his "Future of Programming" talk. Instead we have developers still using systems as if UNIX had been released last year.
- lispm 13y ago
  At the European Common Lisp Meeting later this year in Berlin/Germany I'm probably demoing a real hardware Symbolics Lisp Machine and its OS...
  - pjmlp 13y ago
    Sounds tempting, as I live in Germany. Thanks for the hint.

angersock 13y ago

Symbolics stuff not just worked, it worked remarkably well on the very modest hardware and solved real word problems. Sadly, sadly, that's not enough. Oftentimes, that doesn't even matter.

mwfunk 13y ago

This comment is to programming language analysis what Pitchfork reviews are to music analysis- lots of tribalism, lots of emotion, lots of apparently non-self-aware hyperbole, and entertaining as long as what the reader is looking for is entertainment and not actual analysis of anything. If your goal as a programmer is simply to have fun, then carry on, but if your goal is to have a handle on whatever scraps of objective truth are out there (or even just to solve concrete problems) then you may want to devote at least some tiny part of your time to trying to see things from other people's perspectives. Those other people may not necessarily be correct about anything, but when it comes to engineering even the faintest wisp of objective truth is worth a lot more than strongly expressed emotions, no matter how poetic it may seem to you.

dschiptsov 13y ago
Let's say that Lisp is very different because it was based on a "good ideas", well researched in "good places" like MIT AI and CS labs (no punks could get there). It has something to do with shoulders of Titans. The set of selected "good ideas" is intentionally keept small and well-balanced. Let's take a walk. The "layers of DSLs" metaphor mimics as close as possible the way our mind uses a language, which we call "verbal", or "logical" mind, as opposed to "non-verbal, ancient, emotional" mind, which is based on evolved reflexes, captured by genes (Sorry!). We are using symbols to refer to inner representations (concepts) we have in our minds. so "everything is a symbol" (just a reference to a "storage") is a "good idea". When we're talking about some specific context (situation, or "domain") we tend to use some reduced, appropriate set of words (symbols) related to it, along with usual "glue". This what we call Domain Specific Language, or a Slang, if you wish. This is also a "good idea", groups has slangs. Layered structure is, in some sense, what the Nature is. Atoms, molecules, proteins, tissues,, organs, systems, brain, body, you see. So, layers of data is a good idea, but layers of DSLs is even better one. It not only mimics how the world is, but how we should structure our programs. Neither the language nor its layers are set in stone, they could be transformed, extended, adapted using the very same mechanism which underlies it. Iterative looping constructs, for example, were build out of macros, and the Loop DSL is the most striking example of how a language could be expended with itself as a Meta-language. Some "good people", like R. Gabriel, have argued that we need more complex control constructs (special forms) as long as we are trying to write complex programs (language should be adequate to the domain), so, the ability do define new special forms as we go, without breaking everything, is a "good idea". This is, btw, the idea behind the recursive bottom-up process of software development, popularized by SICP and championed by pg and rtm. Language should evolve together with our understanding of the problem domain. Structures is also a DSL. This gives us the way to structure our data (everything is an expression in a Lisp, everything could be evaluated, this is another very "good idea") to mimic or represent more conveniently the objects of real world. Structures could be nested, getters and setters were created automatically, but could be redefined, etc. So, by extending the language with new, appropriate constructs (by defining new special forms) we could improve our way of modeling the reality and create better "inner representations" for the concepts we made (captured)? Seems like a "good idea". But wait, because everything is an expression (a Lisp form) which could be evaluated, why not just put code blocks (expressions) into the same structures? Thus we have "data structures" which captures not just characteristics (state) but also behavior of real world "objects". To capture the behavior we need the notion of "protocols", which is just a named set of generic functions. So we have defprotocol which, essentially, creates a structure and binds names (symbols) to procedures (expressions) which consists of Lisp forms. Thus we got MOP implemented, which is the basis of CLOS. I forgot to mention, that since everything is a symbol (reference) we could combine "objects" into lists and other aggregates, map them, reduce them - the whole set of layers of language "below" are available. This doesn't mean that this is the only way to program, this is just one of the possible programming paradigms. What is really matter is that we could, by using the very same means of combination and abstraction "import" any other paradigm we wish. And everything so uniform and concise that it could be easily traced back to "conses". btw, this is not a "strict", "rigid", "set in stone" language (it is a nonsense to try to "fix" a language, it contradicts with the its nature). We have reasonable, "evolved" defaults, such as Lexical scoping for variables, but we could have Dynamic scoped ones if we wish. Thus, it is possible to extend the language with "non-local exit" control structures, which is your fucking Exceptions. Immutablity has also reasonable defaults. List and mapping functions are always producing a new copy of a list, leaving original ones unaltered, while their "destructive" equivalents were segregated by following an explicit calling convention (Scheme is famous for this). Evaluation strategies could also be explicitly selected, so lazy lists or streams could be defined using the very same conses and macros and list notation. Being a small language (after all the transformations - macro-expansions, rewriting rules, inlining has been done) it could be efficiently compiled (using a compiler written in itself) diretly into Machine code, which runs on more plathorms than fucking JVM. This is what some people are considered as a work of a fine art, and called "programmable programming language". But this is only a half of the story. There were machines (a hardware FSM if you wish) which was able to run the Lisp code efficiently. But this is another story.

AnimalMuppet 13y ago

If you build a better programming language, and the world does not beat a path to your door (even after 50 years), that's because the world is too stupid to appreciate the genius of your beautiful language? Right. Grow up, kid. Lisp has its virtues, but the Lisp evangelists/cheerleaders/fanboys would be more effective at converting the rest of us if they quit assuming that anyone who disagreed with them was too stupid to see the obvious virtues of their wonderful language. And don't say that you don't care whether others like your language. You care whether others like it enough for businesses like Symbolics to survive, so that you don't have to visit bitsavers to see this stuff that you love so much.

stonemetal 13y ago

the whole OS, which was available of dynamic modification and extension by the programmer, Sounds like a nightmare, writing code for an OS where every chucklehead with a keyboard has modified it just because they can. Rather sounds like the curse of the gifted[1] writ large. Sure it was cooler and had neat features but couldn't reliably deliver over the long term. [1] https://news.ycombinator.com/item?id=7219872 https://news.ycombinator.com/item?id=7219872