6 ms·

Slightly tangential, but I wish some Lisp would make a serious comeback and challenge mainstream languages. For this purpose, libraries are essential. So better

by nextos 7y ago

Slightly tangential, but I wish some Lisp would make a serious comeback and challenge mainstream languages. For this purpose, libraries are essential. So better tooling would help, and that's why Ultralisp and Quicklisp are interesting. Clojure is very nice. I have used it for several projects. But sometimes I would prefer not to rely on Java libraries so much, and cleaner stack traces. Racket may get some critical momentum now, with the whole merge with Chez. I don't have high hopes for a Common Lisp implementation, as the ecosystem has become too fragmented and stagnant. But I wish I could be surprised here. Shen introduced some great ideas to make a powerful static typing an option in Lisp [1]. [1] http://www.shenlanguage.org/ http://www.shenlanguage.org/

andrenth 7y ago
Re statically typed Lisp, I’m keeping an eye on Carp [1] which seems to be a quite active project. [1] https://github.com/carp-lang/Carp https://github.com/carp-lang/Carp
- simias 7y ago
  Common lisp meets Rust, I'm intrigued. All these new exciting programming languages over the past ~5 years or so are quit exciting. I'm starting to believe that in the not so far future we'll look back on that time period between the late 90s up to the mid 2010s as some kind of a dark age for programming, where we kept using those inelegant, inefficient, hacky languages carried by Moore's law and an incredible demand for new software being written in huge quantity extremely fast, quality be damned. Now that the gold rush starts to cool down there seem to be a lot of very interesting work to take a few steps back and do it right.
  - neilv 7y ago
    I think your dark age and gold rush theory has some truth to it. The whole industry culture and practices changed during that period, but we're starting to see things like people interested in Rust, even though it's not pitched as a faster way to make slicker generic Web sites and phone apps. I'm also hoping that Racket (which is is like a secret oasis community) will get more attention, and someone will dust off some old Paul Graham writings about startups and Lisp, and some startups (probably ones who're not just doing another cookie-cutter madlibs startup) will decide to use Racket initially. (Disclosure: I have an interest in promoting Racket, because I'd love to help build startups in Racket, and also recruit top programmers with Racket as a carrot.)
    - andrenth 7y ago
      What do you think are good learning resources for learning racket for an experienced (functional) programmer? Is there a book that isn’t focused on learning to program?
      - nextos 7y ago
        Are you experienced in Common Lisp? Racket is multiparadigm too. As such, many good multiparadigm books will be of great help. E.g. SICP, but also the much less known yet equally fantastic CTM. None are written in Racket, although SICP with Scheme is close, but many concepts can be ported. There's also excellent Lisp literature like Lisp in Small Pieces or PAIP, that are always worth to consider. Racket also implements most of http://www.eopl3.com/ http://www.eopl3.com/, which is a great textbook.
        andrenth 7y ago
        Thanks. I don’t know Common Lisp, but I guess the knowledge will be transferable.
        amirouche 7y ago
        quick read https://github.com/a-guile-mind/book/#a-guile-mind-book https://github.com/a-guile-mind/book/#a-guile-mind-book
        neilv 7y ago
        For working through SICP, you can actually use the Racket tools, like the DrRacket IDE. We rigged up a simple `#lang sicp` that emulates the version of MIT Scheme used for SICP problem sets: https://docs.racket-lang.org/sicp-manual/ https://docs.racket-lang.org/sicp-manual/
      - neilv 7y ago
        For an FP person, you might want to instead start with skimming, for half an hour, the R5RS or R7RS Scheme paper, for the base language from which Racket grew (don't worry about the first-class continuations unless you want to). Then go to the Racket Guide or Racket Reference table of contents, to look for things that you might be looking for from your past FP experience, like `match` (though it's maybe not used as much as you're familiar with). Then look into some of the strengths of Racket, like syntax extension and `#lang`. (If you want additional treatment of syntax extension and `#lang`, see things like Hendershott's "Fear of Macros", and Butterick's book.) Also skim the large list of add-on packages, to get a sense of what's there. Eventually read through the Guide and Reference at your leisure. There's an imposing wall of manuals at: https://docs.racket-lang.org/ https://docs.racket-lang.org/ Racket isn't purely FP, but it can be used that way, even with the base language. There's also at least one lazy `#lang`, and you can make more.
  - andrenth 7y ago
    After working a lot with statically typed languages, I’ve been doing some work recently with a dynamic language, and it feels refreshingly fun... Granted, I’ve been using elixir and erlang, where the use of pattern matching matching and immutability give you a lot of the benefits that modern static languages have, but I wouldn’t mind a new wave of modern dynamic languages, or at least static ones that feel more dynamic (Carp may fit in that spot).
    - deepaksurti 7y ago
      If you haven't looked at it, then (lisp (flavoured (Erlang))) will appeal to you. [1] [1] http://lfe.io http://lfe.io
  - pjmlp 7y ago
    Research languages like Mesa/Cedar or Modula-3. We had a dark age of too much VM and scripting languages, and only now getting back how computing could have looked like. For example, given Anders background imagine how .NET would have been if it was fully AOT compiled and the same low level features from Delphi since version 1.0. Or if C++ Builder wasn't the only surviving example to RAD development with C++, before others started to build on top of LLVM toolchain.
- jakeogh 7y ago
  Another is clasp https://github.com/clasp-developers/clasp https://github.com/clasp-developers/clasp There are a few interesting talks on yt: https://www.youtube.com/watch?v=mbdXeRBbgDM https://www.youtube.com/watch?v=mbdXeRBbgDM
  - mehrdadn 7y ago
    Oh man this is going to be a fun naming conflict to resolve... https://github.com/google/clasp https://github.com/google/clasp
    - deleted 7y ago
      [deleted]
- dannyobrien 7y ago
  There’s also Coalton — a typed implementation within Common Lisp https://github.com/stylewarning/coalton/ https://github.com/stylewarning/coalton/
slaymaker1907 7y ago
Racket in particular has one of the easiest ways to use an SMT solver via Rosette (also super easy to install).
mdhughes 7y ago
I spend most of my time now in Chicken Scheme http://call-cc.org/ http://call-cc.org/ and it's very productive, has a ton of libraries ("eggs"), and makes nice, fast native binaries. Scheme's right on the edge of ascetic discipline and productive tooling, where so many languages are much too far either way. Racket's weird, not quite a Scheme anymore, tons of libraries but they're often hard to use, and the object system infected too much of it. And performance is poor even with Chez underneath, there's just too much stuff on top. It's a better teaching tool with the tutorial sub-languages than a production language. I can't work in CLISP, it's like scavenging a junkyard for parts where some work, some haven't for 30 years. Some people love that experience. Strong typing (also in Typed Racket) isn't going to improve anything, but it's good for marketing to enterprise people.
tpfour 7y ago
I suggest you take a look at Gerbil Scheme, based on Gambit-C. https://cons.io https://cons.io
quotemstr 7y ago
I really wish someone would put together a new standardization of Common Lisp. The language could be much better with a few minor tweaks: for example, (function +) should be a generic function --- that it is isn't is a silly oversight. Compiler macros should have access to type inference information so that they can do a better job: right now, they're purely syntactic and give up lots of optimization potential as a result.
- flavio81 7y ago
  We already have all of the above in the form of libraries. Common Lisp is extensible.
  - quotemstr 7y ago
    We don't have any of those. #'+ is part of the core and can't be extended. There's also no facility for type propagation in library form.
    - kgwgk 7y ago
      You can shadow + and use your own implementation in your code, falling back to cl:+ when appropriate. Changing the existing language may be difficult, but building a modified language on top of it is possible: see Shen.
    - vindarel 7y ago
      To extend #'+, equality functions and much more, see https://github.com/alex-gutev/generic-cl/ https://github.com/alex-gutev/generic-cl/. See also https://github.com/pnathan/generic-comparability https://github.com/pnathan/generic-comparability
pjmlp 7y ago
The best tooling still survives on Allegro and LispWorks implementations, but without a major backer pushing it down dev throats like the OS vendors do with their SDKs, there is little hope for such uptake. We are better off hoping for Lisp inspired languages like Julia or Clojure to win wider market adoption. Maybe what is really missing is having a Lisp for WebAssembly, being advertised as the best implementation available everywhere and such.
- svetlyak40wt 7y ago
  There is a thread on Reddit, discussing different possibilities to build webasm from Common Lisp: https://www.reddit.com/r/lisp/comments/7z7wuq/has_anyone_considered_or_started_a_project_to/ https://www.reddit.com/r/lisp/comments/7z7wuq/has_anyone_con...
  - pjmlp 7y ago
    Thanks, looks interesting.
flavio81 7y ago
>I don't have high hopes for a Common Lisp implementation, as the ecosystem has become too fragmented and stagnant. I work on CL everyday and don't think it's fragmented. Stagnant, maybe, when comparing it to the mainstream languages.

by nextos 7y ago

andrenth 7y ago

Re statically typed Lisp, I’m keeping an eye on Carp [1] which seems to be a quite active project. [1] https://github.com/carp-lang/Carp https://github.com/carp-lang/Carp

simias 7y ago
Common lisp meets Rust, I'm intrigued. All these new exciting programming languages over the past ~5 years or so are quit exciting. I'm starting to believe that in the not so far future we'll look back on that time period between the late 90s up to the mid 2010s as some kind of a dark age for programming, where we kept using those inelegant, inefficient, hacky languages carried by Moore's law and an incredible demand for new software being written in huge quantity extremely fast, quality be damned. Now that the gold rush starts to cool down there seem to be a lot of very interesting work to take a few steps back and do it right.
- neilv 7y ago
  I think your dark age and gold rush theory has some truth to it. The whole industry culture and practices changed during that period, but we're starting to see things like people interested in Rust, even though it's not pitched as a faster way to make slicker generic Web sites and phone apps. I'm also hoping that Racket (which is is like a secret oasis community) will get more attention, and someone will dust off some old Paul Graham writings about startups and Lisp, and some startups (probably ones who're not just doing another cookie-cutter madlibs startup) will decide to use Racket initially. (Disclosure: I have an interest in promoting Racket, because I'd love to help build startups in Racket, and also recruit top programmers with Racket as a carrot.)
  - andrenth 7y ago
    What do you think are good learning resources for learning racket for an experienced (functional) programmer? Is there a book that isn’t focused on learning to program?
    - nextos 7y ago
      Are you experienced in Common Lisp? Racket is multiparadigm too. As such, many good multiparadigm books will be of great help. E.g. SICP, but also the much less known yet equally fantastic CTM. None are written in Racket, although SICP with Scheme is close, but many concepts can be ported. There's also excellent Lisp literature like Lisp in Small Pieces or PAIP, that are always worth to consider. Racket also implements most of http://www.eopl3.com/ http://www.eopl3.com/, which is a great textbook.
      - andrenth 7y ago
        Thanks. I don’t know Common Lisp, but I guess the knowledge will be transferable.
        amirouche 7y ago
        quick read https://github.com/a-guile-mind/book/#a-guile-mind-book https://github.com/a-guile-mind/book/#a-guile-mind-book
      - neilv 7y ago
        For working through SICP, you can actually use the Racket tools, like the DrRacket IDE. We rigged up a simple `#lang sicp` that emulates the version of MIT Scheme used for SICP problem sets: https://docs.racket-lang.org/sicp-manual/ https://docs.racket-lang.org/sicp-manual/
    - neilv 7y ago
      For an FP person, you might want to instead start with skimming, for half an hour, the R5RS or R7RS Scheme paper, for the base language from which Racket grew (don't worry about the first-class continuations unless you want to). Then go to the Racket Guide or Racket Reference table of contents, to look for things that you might be looking for from your past FP experience, like `match` (though it's maybe not used as much as you're familiar with). Then look into some of the strengths of Racket, like syntax extension and `#lang`. (If you want additional treatment of syntax extension and `#lang`, see things like Hendershott's "Fear of Macros", and Butterick's book.) Also skim the large list of add-on packages, to get a sense of what's there. Eventually read through the Guide and Reference at your leisure. There's an imposing wall of manuals at: https://docs.racket-lang.org/ https://docs.racket-lang.org/ Racket isn't purely FP, but it can be used that way, even with the base language. There's also at least one lazy `#lang`, and you can make more.
- andrenth 7y ago
  After working a lot with statically typed languages, I’ve been doing some work recently with a dynamic language, and it feels refreshingly fun... Granted, I’ve been using elixir and erlang, where the use of pattern matching matching and immutability give you a lot of the benefits that modern static languages have, but I wouldn’t mind a new wave of modern dynamic languages, or at least static ones that feel more dynamic (Carp may fit in that spot).
  - deepaksurti 7y ago
    If you haven't looked at it, then (lisp (flavoured (Erlang))) will appeal to you. [1] [1] http://lfe.io http://lfe.io
- pjmlp 7y ago
  Research languages like Mesa/Cedar or Modula-3. We had a dark age of too much VM and scripting languages, and only now getting back how computing could have looked like. For example, given Anders background imagine how .NET would have been if it was fully AOT compiled and the same low level features from Delphi since version 1.0. Or if C++ Builder wasn't the only surviving example to RAD development with C++, before others started to build on top of LLVM toolchain.
jakeogh 7y ago
Another is clasp https://github.com/clasp-developers/clasp https://github.com/clasp-developers/clasp There are a few interesting talks on yt: https://www.youtube.com/watch?v=mbdXeRBbgDM https://www.youtube.com/watch?v=mbdXeRBbgDM
- mehrdadn 7y ago
  Oh man this is going to be a fun naming conflict to resolve... https://github.com/google/clasp https://github.com/google/clasp
  - deleted 7y ago
    [deleted]
dannyobrien 7y ago
There’s also Coalton — a typed implementation within Common Lisp https://github.com/stylewarning/coalton/ https://github.com/stylewarning/coalton/

slaymaker1907 7y ago

Racket in particular has one of the easiest ways to use an SMT solver via Rosette (also super easy to install).

mdhughes 7y ago

I spend most of my time now in Chicken Scheme http://call-cc.org/ http://call-cc.org/ and it's very productive, has a ton of libraries ("eggs"), and makes nice, fast native binaries. Scheme's right on the edge of ascetic discipline and productive tooling, where so many languages are much too far either way. Racket's weird, not quite a Scheme anymore, tons of libraries but they're often hard to use, and the object system infected too much of it. And performance is poor even with Chez underneath, there's just too much stuff on top. It's a better teaching tool with the tutorial sub-languages than a production language. I can't work in CLISP, it's like scavenging a junkyard for parts where some work, some haven't for 30 years. Some people love that experience. Strong typing (also in Typed Racket) isn't going to improve anything, but it's good for marketing to enterprise people.

tpfour 7y ago

I suggest you take a look at Gerbil Scheme, based on Gambit-C. https://cons.io https://cons.io

quotemstr 7y ago

I really wish someone would put together a new standardization of Common Lisp. The language could be much better with a few minor tweaks: for example, (function +) should be a generic function --- that it is isn't is a silly oversight. Compiler macros should have access to type inference information so that they can do a better job: right now, they're purely syntactic and give up lots of optimization potential as a result.

flavio81 7y ago
We already have all of the above in the form of libraries. Common Lisp is extensible.
- quotemstr 7y ago
  We don't have any of those. #'+ is part of the core and can't be extended. There's also no facility for type propagation in library form.
  - kgwgk 7y ago
    You can shadow + and use your own implementation in your code, falling back to cl:+ when appropriate. Changing the existing language may be difficult, but building a modified language on top of it is possible: see Shen.
  - vindarel 7y ago
    To extend #'+, equality functions and much more, see https://github.com/alex-gutev/generic-cl/ https://github.com/alex-gutev/generic-cl/. See also https://github.com/pnathan/generic-comparability https://github.com/pnathan/generic-comparability

pjmlp 7y ago

The best tooling still survives on Allegro and LispWorks implementations, but without a major backer pushing it down dev throats like the OS vendors do with their SDKs, there is little hope for such uptake. We are better off hoping for Lisp inspired languages like Julia or Clojure to win wider market adoption. Maybe what is really missing is having a Lisp for WebAssembly, being advertised as the best implementation available everywhere and such.

svetlyak40wt 7y ago
There is a thread on Reddit, discussing different possibilities to build webasm from Common Lisp: https://www.reddit.com/r/lisp/comments/7z7wuq/has_anyone_considered_or_started_a_project_to/ https://www.reddit.com/r/lisp/comments/7z7wuq/has_anyone_con...
- pjmlp 7y ago
  Thanks, looks interesting.

flavio81 7y ago

>I don't have high hopes for a Common Lisp implementation, as the ecosystem has become too fragmented and stagnant. I work on CL everyday and don't think it's fragmented. Stagnant, maybe, when comparing it to the mainstream languages.