9 ms·
If you took a Common Lisp programmer from the early to mid 90s in a time machine to today, very little about current programming languages would seem novel or a
by jimbokun 12y ago
If you took a Common Lisp programmer from the early to mid 90s in a time machine to today, very little about current programming languages would seem novel or an advance over what he or she was using then.
I think this is a reason for much of the smugness of Lisp programmers. Whatever features you think are new or cool or advanced about your programming language, Lisp probably got there first.
- lmm 12y agoNonsense. We've figured out how to do type systems. We can even fully infer types if you're willing to accept some quite reasonable restrictions on how polymorphic your code is. We have a bunch of reasonable approaches to effect tracking, which Lisp folk used to have to do by hand (that story about the T garbage collector sounds like the most unmaintainable piece of code I've ever heard of). We know how to solve the expression problem. Modern "pragmatic"-oriented languages have little that wasn't in Lisp - or in Algol. Which is fine! The innovation is about the wider ecosystem (a lisp programmer from the '90s would be amazed by CPAN, never mind maven), or about making common tasks easy (a lisp programmer might eventually put together a collection of idiosyncratic macros with much of the functionality of Rails, but that wouldn't be a project you could hire someone else to maintain). OTOH modern "researchey" languages, like Coq or even Haskell, are far far ahead of Lisp.
- masklinn 12y ago> Nonsense. We've figured out how to do type systems. We can even fully infer types if you're willing to accept some quite reasonable restrictions on how polymorphic your code is. That dates back to the 70s: http://en.wikipedia.org/wiki/ML_(programming_language) http://en.wikipedia.org/wiki/ML_(programming_language)
- eudox 12y ago>a lisp programmer might eventually put together a collection of idiosyncratic macros with much of the functionality of Rails, but that wouldn't be a project you could hire someone else to maintain There is, in fact, such a thing as Common Lisp libraries. See https://github.com/quicklisp/quicklisp-projects https://github.com/quicklisp/quicklisp-projects 1034 projects with ~48 waiting to be added.
- lmm 12y agoSure, but is there a one-stop framework that lets you write a CRUD web application as fast as you can with Rails? Was there such a thing in the '90s?
- mrottenkolber 12y agoNo, CL has like 10 different web frameworks or so. I never used any of them, not a big fan of Rails either though. Talking about the 90s, there was no Ruby. But I guess we could have had Lisp on Lanes in the 90s, if there had been demand.
- dragonwriter 12y ago> Talking about the 90s, there was no Ruby. There was Ruby publicly released for a little under half of the 1990s (from late 1995.) There wasn't Rails until a decade later, though.
- mcguire 12y agoCommon Lisp has about 10 different anything frameworks, which nobody in particular uses in favor of writing their own, mostly because they can. Many of the ten are in fact written into the standard. Common Lisp isn't so much a "language for writing languages" as a giant bag of everything.
- zem 12y agoto quote an old quip: you have a problem. common lisp has a clunky solution that's built into the standard, and scheme has a beautiful one that doesn't work in your dialect.
- eudox 12y agoFramework: Caveman2[0] or Ningle[1], which run on Clack[2] (like Rack/WSGI), which supports five backend servers. Templates: Djula[3], closure-template[4]. ORM: Crane[5], Postmodern[6]. [0] https://github.com/fukamachi/caveman https://github.com/fukamachi/caveman [1] https://github.com/fukamachi/ningle https://github.com/fukamachi/ningle [2] https://github.com/fukamachi/clack https://github.com/fukamachi/clack [3] https://github.com/mmontone/djula https://github.com/mmontone/djula [4] https://github.com/archimag/cl-closure-template https://github.com/archimag/cl-closure-template [5] https://github.com/eudoxia0/crane https://github.com/eudoxia0/crane [6] http://marijnhaverbeke.nl/postmodern/ http://marijnhaverbeke.nl/postmodern/
- tel 12y agoTo be clear, they were far ahead of lisp in the 90s too. The major innovation is probably more societal in these languages. We discovered that they really are much better for writing reusable abstractions on the level of the whole community. We also ran into some issues with scaling those abstractions at the level of 10s of thousands of packages and are slowly coming to solve them.
- progman 12y ago> OTOH modern "researchey" languages, like Coq or even Haskell, are far far ahead of Lisp. I know Common Lisp well, and I honestly tried to learn and to use Haskell. I realized that Haskell has the advantage of a strong type system but it seems only to be useful for language research (compiler writing) and mathematical applications. Haskell is (in my case) almost useless for every day real world applications. It is a very good choice if I know the algorithm and data structures exactly in advance. But real world applications often require changes which are not predictable. It is a pain to align a whole Haskell project according to new requirements to make the whole system work again. It takes far too much time, and I wonder where the benefits are if other weaker typed languages can do the same job as well, or even better. In the Lisp world I can develop prototypes very quickly. And if I need a strong type system as in Haskell then I can use Shen (shenlanguage.org) which has a strong rule based type system on top of Lisp. That means that I can use both worlds -- the default dynamic system of Lisp, and the strong type system of Shen. Lisp is still very powerful and yet small in comparison to the huge LLVM system of Haskell. It can be used on embedded systems (ECL for instance) which Haskell is not able to do (AFAIK). I don't know what you exactly mean with "tracking". If that means tracing then Lisp even offers backtracking (debugging back in time), and I think almost every Lisp programmer knows Slime. So the claim that Haskell is "far far ahead" of Lisp is not true at all. The only real weak point of Lisp is a good GUI library. I wish there were strong support of Qt and HTML5. Another favorite language of me is Nimrod because it joins the best of several languages (Python, Perl, Lisp and C) together.
- dragonwriter 12y ago> It is a very good choice if I know the algorithm and data structures exactly in advance. I'd say the exact opposite: the great strength of Haskell lies in its powerful support for abstracting things out so that these things can easily evolve independently. The hard part of taking advantage of this seems to me to be that we're used as programmers to not having those tools, so it is hard to get used to thinking about doing that kind of abstraction.
- progman 12y agoI understand that. I really like Haskell but I wonder if the type system is actually too strong for the real world. Generalizing algorithms sounds nice but if Haskell is so powerful, why is the Haskell community still not able to provide a convenient working package manager? Perl has CPAN, Ruby has Gems, Lisp has ASDF and Quicklisp but Haskell is still stuck with buggy Cabal. I have been in the Cabal hell many times. I know that there are sandboxes, and I considered to install Nix and NixOS just to use Haskell. It surprises me very much that a simple package manager is such a big issue in Haskell. This is a typical example for a real world application that causes strange difficulties in Haskell where other languages have no issues at all. FPcomplete is already working on a new solution with snapshots. I am curious how convenient it will be. https://www.fpcomplete.com/blog/2014/08/announcing-stackage-server https://www.fpcomplete.com/blog/2014/08/announcing-stackage-...
- kd0amg 12y agoWe can even fully infer types if you're willing to accept some quite reasonable restrictions on how polymorphic your code is. Personally, I don't consider "don't pass a polymorphic function to another polymorphic function" and "don't demand a polymorphic function as an argument" to be all that reasonable.
- wes-exp 12y agoType systems are the one exception, but it still remains broadly true that Lisp was way ahead of everybody. There are many things we could talk about besides type systems: Lambda expressions - just now reaching Java and C++, been in Lisp forever Garbage collection – (obviously) Turing-complete (edit: fully evaluating) macro systems – I've heard C++ is moving in this direction (not sure to be honest) but Lisp is still ahead on this Gradual/optional typing – Others have been moving towards this, CL has had it forever Interactivity/REPL – e.g. Swift may finally give a REPL to systems programmers, Lisp has had it forever Dynamism/late-binding – Lisp is still way ahead on this, goes hand-in-hand with interactivity Everything serializable – Lisp is still ahead Structured code editing (paredit) – Lisp is still ahead, not sure anyone else even knows what this is Multiple inheritance – I think this is coming to Java finally Image systems (hibernating a running process) – Still ahead Condition system / advanced exception handling – Still ahead Functional programming techniques (map, reduce, etc.) – Still ahead Keyword arguments – Recently added to Ruby, Lisp has had them forever
- dllthomas 12y ago"Turing-complete macro system - I've heard C++ is moving in this direction (not sure to be honest) but Lisp is still ahead on this" 1) Turing-complete is a bug, not a feature. 2) C++ template metaprogramming has been Turing Complete for ages. 3) There are nonetheless significant limitations on what you can do with templates in C++, compared to what you can do with macros in Lisp. "Turing Complete" is a theoretical construct that doesn't really mean much other than giving you easy ways to prove that certain questions about the system can't always be answered. One significant reason for this is that "Turing Complete" merely means that you can embed any computation in the system in some encoding - with something like a macro system, the encoding you generate is the whole point.
- wes-exp 12y agoI understand what you're saying. What I mean is not the trivial "nand is turing complete" sense, which I agree is harmful and silly, but full eval capabilities. Lisp macros can fully evaluate Lisp code, and I consider this a great feature, but I don't know how else to describe them. "Full evaluation macros"?
- kazinator 12y agoBut you only have to infer types because you insisted on removing them from the run-time information. Sure, you're clearing the road of fallen logs, but they fell there by your own axe. Having the type there at run time is smarter than working up a lather prior to run time to avoid having it there. Also, real systems don't have a well-defined "compile" and "run time": the two are intertwined. Compile time is just the compiler's run time, and we need access to the language at that time, and has to be type-safe also, and we would like that comile-time code to itself be compiled (and to have access to the language during that code's compilation ...).
- sedachv 12y ago> We've figured out how to do type systems This is probably the only valid point you have. > a lisp programmer from the '90s would be amazed by CPAN, never mind maven CPAN was started in 1997. A lot of Lisp programmers back then were also doing Perl, and a few people who were doing Perl then are doing Lisp now. Whoever is "amazed" by Maven should go jump off a bridge. > We have a bunch of reasonable approaches to effect tracking, which Lisp folk used to have to do by hand I'm assuming you're talking about generalized arrows or something and not monads. Generalized arrows partly came out of work on linear types and parallelism done by Lisp people in the 80s and early 90s. > We know how to solve the expression problem. Thanks mostly to PLT/Racket people: http://en.wikipedia.org/wiki/Expression_problem http://en.wikipedia.org/wiki/Expression_problem > blah blah blah Rails functionality Rails doesn't have functionality, Rails has a bunch of shitty complicated ways of doing web programming, with a bunch of shitty poorly maintained Ruby libraries (most of the good ones are just FFI into C libraries). If you're going to talk about modern "practical" languages, you could do better. Go is pretty great except it doesn't have exceptions. JavaScript solved code distribution and program-level virtualization. Those are much better comparisons.
- deleted 12y ago[deleted]
- Stubb 12y agoYeah, I think that most programming language developments since the '70s have involved putting some ideas from C and Lisp in a blender for a few minutes. The main advances IMO have come in the areas of IDEs, build systems, and language ecosystems. I'm a mediocre programmer at best who's done a bunch of Lisp in the past. I loved using it, but these days I rely on Ruby for getting things done because it gives me what I need from Lisp backed up with a package system that just works. I'd rather work in Lisp, but I can make more progress in Ruby.
- ianstallings 12y agoAnd smalltalk in that mix too.
- pjmlp 12y agoFrom the 70's I would rather wish that the mix would be Lisp, Smalltalk, Cedar and CLU. No need for C.
- Avshalom 12y agoSure but that can be said of half a dozen languages in the 70s. Unix taking over the world ended up convincing two generations that C was state of the art.
- pjmlp 12y agoSometimes I feel like a Roman after the Empire downfall. So many choices for systems programming gone thanks to UNIX, and now kids think C is the only way.