3 ms·
> I'm not convinced that LISP was ever the-right-thing. Remember that this has to be read in historical context. At the time C was invented, things like garbag
by kqr 2y ago
> I'm not convinced that LISP was ever the-right-thing.
Remember that this has to be read in historical context. At the time C was invented, things like garbage collection, message-passing object-orientation, generics, rich sets of conditionals, first-class functions, etc. were brand spanking new. They were The Right Thing to do (even judged in the harsh light of hindsight), but also quite complicated to implement – so much so that the New Jersey people skipped right past most of it.
Today these things are par for the course. At the time, they were the The Right Thing that made the system correct but complex, and had adoption penalties. As time passes, the bar for The Right Thing shifts, and today, it would probably not be embodied by Lisp, but maybe by something like Haskell or Rust?
- pjc50 2y ago> things like garbage collection, message-passing object-orientation, generics, rich sets of conditionals, first-class functions, etc. were brand spanking new. They were The Right Thing to do I quite like this view, because these things have clearly been copied everywhere such as my language of choice C#, but the one thing that nobody copied is the one that Lisp programmers rave about most: homoiconicity (brackets everywhere).
- pjmlp 2y agoLisp-2, Prolog, Dylan, Erlang, Julia, R.... Are all homoiconic without being full of parenthesis all over the place, the actual meaning is code and data being interchangeable.
- BoingBoomTschak 2y agoI think following what's written in Wikipedia (https://en.wikipedia.org/wiki/Homoiconicity#Implementation_methods https://en.wikipedia.org/wiki/Homoiconicity#Implementation_m...) and only using the adjective for stuff like Lisp, Tcl, Rebol is better than diluting its meaning to the point where it applies to any language with tree-sitter bindings and a parser.
- kragen 2y agoProlog, Dylan, Julia, and R are stuff like Lisp, Tcl, and Rebol. I don't know about Erlang, and I don't know what pjmlp means by "Lisp-2", which I normally interpret as meaning a Lisp with different namespaces for functions and variables, following Steele's terminology.
- susam 2y ago> ... I don't know what pjmlp means by "Lisp-2", which I normally interpret as meaning a Lisp with different namespaces for functions and variables ... There indeed was a language named LISP 2: https://dl.acm.org/doi/pdf/10.1145/1464291.1464362 https://dl.acm.org/doi/pdf/10.1145/1464291.1464362 I posted it on HN two weeks ago but it didn't get much traction: https://news.ycombinator.com/item?id=41640147 https://news.ycombinator.com/item?id=41640147
- kragen 2y agoAha, thanks!
- deleted 2y ago[deleted]
- BoingBoomTschak 2y agoLooking at https://docs.julialang.org/en/v1/manual/metaprogramming/ https://docs.julialang.org/en/v1/manual/metaprogramming/, I have a hard time considering it "fully" homoiconic, as the parsed data structure Expr(:call, :+, :a, Expr(:call, :*, :b, :c), 1) isn't the same representation as the code itself, even having some new elements like :call. How it this different from tree-sitter, except that you can feed the modified code back to the language to evaluate? I mean, don't get me wrong, Julia metaprogramming seems lovely, but it just seems to me that the word loses meaning if it can applied to all languages with AST macros, no matter how gnarly the AST data structure is (is Rust homoiconic because of proc_macro?).
- kragen 2y ago
- pjmlp 2y agoAlso Lisp came out in 1958, and ESPOL/NEWP in 1961, PL/I and its derivates, predating C by a decade. Had AT&T been allowed to charge real money for UNIX, and the Worse is Better would never happened.
- linguae 2y agoCounterpoint: Some other “worse” would have probably taken over. We’ve seen this in the personal computing market, where MS-DOS (later Windows) and the x86 won out against competing operating systems and ISAs not because of technical superiority, but because of market forces and cost. Look at the evolution of the Web, especially JavaScript.... It’s likely that Unix might not had spread if AT&T didn’t give it relatively liberal licensing in the pre-divestiture era. But it’s also likely that something else that was cheap and readily adaptable would’ve taken over instead, even if it wasn’t technically superior to its competitors.
- pjmlp 2y agoOr maybe we would be enjoying VMS or something like that, not written in a language that 60 years later after its inception still doesn't do bounds checking and decays arrays into pointers to save typing four characters.
- kragen 2y agoBLISS-11 didn't do bounds-checking either. VMS was my favorite operating system until I got access to a Unix. People chose Unix because it was better—and not just by a little. Handicapping Unix wouldn't have improved the alternative systems.
- pjmlp 2y agoVMS also supported Pascal and BASIC dialects for systems programming, in equal footing to BLISS. People choose free beer, it always goes even if warm.
- kragen 2y agoThis paper was written in 01991. Garbage collection is from 01959. Message-passing (aka object-orientation) is from 01972. C is from 01973. If by "generics" you mean parametric polymorphism, those were added to Ada and C++ in the mid-80s, after having been invented in ML in 01973; in a sense they're an attempt to bring the virtues of dynamically-typed languages like Lisp to statically-typed languages. Even today, I don't think there's a Common Lisp implementation with any kind of parametrically-polymorphic static type system, not even as an optimization. First-class functions are also from 01959, or, arguably from 01936, in the untyped λ-calculus, or 01920, in combinatory logic. Some of these things were brand spanking new in 01973, but none were in 01991. There were Lisp systems for minicomputers like the PDP-11; BSD included one (which I think was ancestral to Franz Lisp) and XLISP ran on CP/M. And of course Smalltalk was developed almost entirely on PDP-11-sized minicomputers. But to my recollection virtually all "serious" software for microcomputers and minicomputers was written in low-level languages like assembly or C into the late 80s, not even PL/M—though Pascal did start to win in the late 80s, in significant part by adopting C's low-level features. Nowadays, microcomputers are big enough and fast enough that Lisp, Haskell, or even Rust is viable. I don't think "the right thing" is mostly about what features your system has. I think it has more to do with designing those features to work predictably and compose effectively.
- samatman 2y ago> > At the time C was invented > C is from 01973. > Some of these things were brand spanking new in 01973 ...right. The Rise of Worse is Better is a memoir, it's set in the past.
- anthk 2y agoEver used SBCL?
- kragen 2y agoI love SBCL. Does Python optimize with parametric polymorphism now?
- Jach 2y agoWhat do you think of Coalton?