GOPHERSPACE.DE - P H O X Y
gophering on hngopher.com
HN Gopher Feed (2017-07-08) - page 1 of 10
 
___________________________________________________________________
Show HN: A notebook-style Common Lisp environment
104 points by cddadr
https://github.com/tamamu/darkmatter
___________________________________________________________________
 
fiddlerwoaroof - 4 hours ago
This is really cool: now, I'll have a reasonable way to introduce
my coworkers to lisp without making them learn emacs at the same
time.  Anyways, would it be possible to include something like
parinfer or paredit here, as well as some reasonable keybindings
for them.  In vim mode, I find these keybindings extremely
ergonomic (loosely based on slimv's settings):
https://github.com/fiddlerwoaroof/dotfiles/blob/master/emacs...
 
kazinator - 4 hours ago
> by cddadrMy TXR Lisp actually has that function. :)Oops, I mean
accessor.
 
math0ne - 1 hours ago
Anyone know of a list or resource that has collected all the of
this type of notebook IDE's?  I know of a few but I'm sure there
are more out there.
 
21 - 6 hours ago
Can somebody comment on the status of Lisp in 2017?If one were to
learn a functional language, is Lisp a good choice today? Or is
Haskell more appropiate?
 
  nikki93 - 5 hours ago
  There are many Lisps, they are not always like MLy languages like
  Haskell. Practical Common Lisp -> On Lisp -> Let Over Lambda with
  Keene and AMOP on the side are good for Common Lisp. Clojure has
  good resources too, Professional Clojure, Learning ClojureScript.
  For Haskell, CIS194 online from UPenn is good. I would suggest
  trying everything out and not being limited by what others think
  and the limits on what they can communicate to you with language.
  Where we are going we need your full expression.
 
  cosarara97 - 5 hours ago
  Lisp is not used as a purely functional language. It has the
  tools to write functional programs, but most lisp code is
  procedural.
 
  pjmlp - 4 hours ago
  > Can somebody comment on the status of Lisp in 2017?Sadly the
  only Lisp environments that resemble in any way the old Lisp
  Machine or Xerox PARC ones are comercial.Emacs is kind of ok with
  SLIME, but it still isn't the same as using Allegro Common
  Lisp[0] or LispWorks [1].[0] - https://franz.com/products
  /allegro-common-lisp/[1] - http://www.lispworks.com/
 
    fiddlerwoaroof - 3 hours ago
    vim + slimv is a pretty good combo, if you're used to vim.
    Also, although it's not widely used, Atom seems to support
    slime:Just grab the latest release from
    https://github.com/slime/slime/releases Install atom-slime and
    sbcl (something like brew install sbcl on osx) Point atom to
    the directory you extracted slime to and then hit packages >
    slime > start
 
      pjmlp - 3 hours ago
      The whole point of my comment was " Lisp environments that
      resemble in any way the old Lisp Machine or Xerox PARC ones".
 
        lispm - 2 hours ago
        These development environments just were IDEs written in
        Lisp, otherwise they most don't have to do much with those
        Lisp Machine IDEs.Most Common Lisp IDEs had a collection of
        these tools: Editor, Listener, Inspector, Debugger,
        Stepper, Preferences, ... Additionally there were various
        browsers, an interface builder, profiler, ...The Lisp
        Machine IDEs had most of these tools, too. But they weren't
        only styled for development, but also for general use. Thus
        a Lisp Listener was not only a REPL, but also a general
        command line interface to interact with the machine. They
        were also more oriented towards group work and had
        additional features like versioned file systems, software
        versioning systems, databases, support for multiple
        programming languages (like C, Pascal, Ada, Fortran,
        Prolog, ...), source repositories, ...Over the years (80s
        onwards) a multitude of these IDEs on Workstations and PCs
        were developed. CMUCL comes with one for X11 (debugger,
        editor, ...), Macintosh Common Lisp, ExperLisp, Procyon
        Common Lisp had one for Macs and Windows, Golden Common
        Lisp had one for Windows, Corman Lisp for Windows, SPE from
        SUN, Lucid CL had one (called XLT, their editor was called
        Helix), Star Sapphire Common LISP had one, Clozure CL has
        one for macOS (which one can run on a current Mac), ...Then
        there were always IDEs based on GNU Emacs or XEmacs. Ilisp
        was once popular, Allegro CL has ELI, SLIME currently is
        the most popular with Sly as a fork. This is not so bad,
        since there are decent versions of GNU Emacs for Windows,
        Unix/GTk+ and macOS.Of the commercial ones only Allegro CL
        (IDE for Windows and Unix/GTk+) and LispWorks (IDE Windows,
        Unix/Gtk+, deprecated for Unix/Motif, macOS) survived with
        regular releases.Of the non-commercial ones SLIME/GNU Emacs
        is the most popular and it is also used by some users of
        Allegro CL and LispWorks. McCLIM lingers in the background
        with a collection of tools which would make an IDE, but it
        lacks one or more better GUI backends.There are also a
        bunch of other ways to use Common Lisp with other editors
        (vim, atom, ...).Now 'darkmatter' is another one. Let's see
        what people think from using it...
 
          pjmlp - 2 hours ago
          Very nice overview, always a pleasure to learn from your
          real life Lisp experience in the original Lisp
          environments.I got mine from endless hours reading the
          manuals, books and papers from those days, so I sometimes
          miss a few details.
 
    cadillackness - 2 hours ago
    I wouldn't recommend Slime to ANYONE because the developers do
    not care about security. The issue[0] of a gaping security hole
    has been open for going on two years.
 
      dasyatidprime - 46 minutes ago
      Did you forget the link?
 
    oblio - 4 hours ago
    The Lisp Works page is kind of cute, but in bad way as far as
    marketing goes, at least in my opinion.The IDE screenshots for
    Windows show off Windows XP.
 
      pjmlp - 4 hours ago
      I don't know how the actual UI currently looks like, but even
      if it still looks like Windows XP, the IDE and Common Lisp
      compiler are still quite ahead compared with what Emacs +
      SLIME are capable of, specially in GUI related Lisp
      development workflows.Maybe they could improve their
      marketing message, but I doubt most wannabe Common Lisp
      developers are willing to pay for comercial tools, with
      enterprise prices, even if they had the best marketing of all
      times.
 
        xfer - 3 hours ago
        Also, unless you are heavily invested in CL, most people
        actually can't afford to pay $600 on a compiler license per
        year.
 
          fiddlerwoaroof - 3 hours ago
          Lispworks has a free "Personal Edition".  It's good
          enough to get through something like Practical Common
          Lisp and get a feeling for writing lisp, however since it
          uses an old version of ASDF, it's a bit difficult to use
          the "modern" quicklisp ecosystem.
 
          lispm - 3 hours ago
          The LispWorks prices are not per year.
 
      lispm - 2 hours ago
      > The IDE screenshots for Windows show off Windows XP.The IDE
      is based on their native GUI backend. Thus it picks up much
      of the looks of the current OS automatically (windows,
      buttons, dialogs, ...).
 
        ssalazar - 2 hours ago
        The point being made is that they apparently haven't
        updated their screenshots in over 10 years, making their
        product seem dated- a pretty big marketing fail.
 
          lispm - 1 hours ago
          LispWorks has been developed from 1987 onwards since 30
          years. They can't update their marketing material every
          year just because someone changed the GUI look. ;-)Though
          I'll propose it to them for the next LispWorks release...
 
          ssalazar - 51 minutes ago
          Software age is a non-sequitur- there are plenty of
          active multi-decade projects that can update their
          marketing material once in ten years.  Nobody suggested
          they do so every year, even though it takes what like an
          hour?  For a product costing $thousands there is not
          really an excuse.
 
          oblio - 1 hours ago
          A major Windows release is kind of a big thing in the
          desktop world.Missing 5 Windows releases is just sloppy:
          Vista, 7, 8/8.1, 10.I'm not saying it's a bad product,
          just that first impressions matter. There's a reason this
          site is full of discussions about conversions and
          funnels.As a side note, Windows is also 30+ years old.
          Hardly new tech these days ;)
 
      ssalazar - 2 hours ago
      Their pricing pages are also a disaster.  I had to drill down
      a few pages deep to find these epic tables:
      http://www.lispworks.com/buy/prices-1c.html which presumably
      could be distilled into 32-bit/64-bit categories plus a
      maintenance add-on.
 
  throwaway7645 - 5 hours ago
  A very tough question. We would need to know more of your
  background. Haskell is purely functional, with anything impure
  cast as a monad I think. OCaml is nice and let's you use OO as
  well. F# is basically OCaml on .NET. Common Lisp is multi-
  paradigm (imperative, functional, OO, even logic)...there are
  several others as well. Clojure is a lisp on the JVM that tries
  to be just functional, but allows you to leverage Java libraries
  when needed. Clojure has a lot of good things going for it, but I
  understand that the debugging experience is inferior to Common
  Lisp as you mainly get Java stack traces. So do you develop on
  Mac, Linux, or Windows? Do you already know Java? Do you need
  multicore parallel programming? How much time do you have to
  invest?
 
  kbp - 5 hours ago
  Lisp isn't really a functional language, it just pioneered a lot
  of concepts in functional programming. It has almost no concept
  of immutability, imperative code is everywhere, and if you try to
  write in a pure functional style you'll probably find it awkward
  compared to something like an ML-style language.Lisp is a
  multiparadigm language. It has closures and higher order
  functions and uses them where they make sense; it also has a lot
  of imperative constructs, and a very sophisticated object system.
  They all work together and make Lisp a unique, interesting
  language. If you're only interested in the functional parts,
  you'd probably be happier with Haskell or Clojure.
 
    doall - 8 minutes ago
    The original LISP is pure functional in the sense that you
    don't change state of an object.
 
    kronos29296 - 5 hours ago
    Clojure is lisp actually. It is also mutable but it makes
    mutability as an explicit transaction but the entire thing runs
    on a JVM so you can use all Java libraries (so no library
    scarcity for lisps). So if you are doing heavy work it is
    either this or Common lisp. Clojure is preferable because Java
    has more momentum than CL.
 
      kbp - 4 hours ago
      Armed Bear Common Lisp[0] runs on the JVM.0: https://common-
      lisp.net/project/armedbear/
 
        kronos29296 - 3 hours ago
        So does Frege [0]. (Your Haskell dialect that runs on JVM)
        But you know what compared to something like SBCL or
        Clojure they are just not that popular. They do deserve
        more attention though.[0] https://github.com/Frege/frege
 
      PuercoPop - 57 minutes ago
      Yes, Clojure is a Lisp. Lisp is also the shorthand way people
      refer to Common Lisp. Lisp in the context of OP means Common
      Lisp.Common Lisp has an implementation, ABCL, which runs on
      top of the JVM. Access to the Java ecosystem is a shared
      trait, not a difference.Being a multi-paradigm language CL
      has a wealth of features That Clojure doesn't and they all
      play well together. Except for the type system and the class
      system.For example, it has places and the ability to define
      your own setf forms.Common Lisp makes iteration easy with the
      lisp macro.Common Lisp has tagbody and gotos so one compile
      FSMs efficientlyCommon Lisp has an object system were the
      semantics are describe using the same object system. So users
      can extend the object model according to their needs.Clojure
      is designed to support one style of programming envisioned by
      its hypemaster. Rich Hickey is a brilliant person, and has
      done an excellent job designing Clojure, butClojure approach
      to 'user erros' is we don't guarantee to signal an error, we
      may do w/e.By momentum you mean it is trending. We know
      mainstream programming is a pop culture, but we shouldn't
      encourage it by recommending one language over another based
      a FAD.
 
  girzel - 5 hours ago
  As far as tooling goes, it's also much less of a pain to set up
  than it used to be. Quicklisp and Roswell[0] make installing and
  maintaining systems much easier -- together they're kind of like
  pyenv/pip for Python, or Opam for Ocaml, or what have you.[0]:
  https://github.com/roswell/roswell
 
  brudgers - 3 hours ago
  To me, the idea of functional languages seems a bit of the wrong
  abstraction and functional programming style is a better one.
  Sure some languages make it easier or harder to program in an
  imperative or functional (or object oriented) style...I mean it
  is easier to program in an object oriented programming style
  using Smalltalk versus Common Lisp (even though CLOS is robust)
  and much easier to program in an imperative style in C than
  Haskell due to the way Haskell treats non-idempotentcy.In 2017
  the status of Lisp is about the same as it has always been only
  more accessible than ever given faster networks over which to
  download tools and to find documentation...e.g. the Racket
  ecosystem. And a person who starts exploring one of the Lisps
  today will learn as much or perhaps more (due to generally better
  access to diverse information about programming) than at points
  in the past.My opinion reflects my bias, but in general I think
  Lisps are more accessible than Haskell because there has been
  more time to smooth over the rough edges related to the more
  significant underlying mathematical/theoretical concepts (lambda
  calculus versus type theory) and perhaps because lambda calculus
  is a bit more easily understood than type theory (or perhaps
  not). There's also a much stronger pedagogical tradition of Lisps
  as teaching languages (forty years or so) at the undergraduate
  level than with Haskell.But in the end, why not both?
 
  xfer - 5 hours ago
  Since you didn't say Common Lisp, i would suggest looking at
  racket: very powerful macro system with safety, support for
  static-type checking, contracts. Unlike common-lisp racket is
  mostly functional and has decent support for object-oriented
  programming too. Most importantly excellent documentation. Pretty
  much the best environment, i have seen academic people produce.
 
    peatmoss - 1 hours ago
    Also, DrRacket. While I generally prefer my emacs, "first learn
    emacs" is a pretty bitter pill to swallow for newcomers.
    Fortunately DrRacket solves that for both newcomers as well as
    experienced folk who just don't want to use emacs. Introducing
    folks to Racket seems to have a lower impedance threshold as a
    result.DrRacket looks a little dated in its vanilla
    configuration, but the layout of the editor / REPL parts can be
    changed around a bit, the color schemes swapped out. There's
    even a paredit mode for DrRacket. Overall, if I were somehow
    coding more exclusively in Racket, I could easily see using and
    extending DrRacket rather than my current emacs.
 
      peatmoss - 1 hours ago
      Oh, DrRacket also dogfoods its own GUI library. Write high
      level Racket; get fully native UI on Mac/Windows/Linux(gtk).
 
        lispm - 10 minutes ago
        The IDE is not very mature. For example if you use the
        dialog to search through files, the UI locks up while
        searching. Usability generally is low...
 
  WalterGR - 2 hours ago
  There was a good amount of discussion about what Common Lisp has
  to offer vs. other programming languages in the comments on
  this:The Common Lisp
  Cookbookhttps://news.ycombinator.com/item?id=14661239262 points
  by macco 9 days ago  | 184 commentsNot so much about CL vs.
  functional languages, but it gives a sense of the current
  scuttlebutt about CL.
 
  reikonomusha - 5 hours ago
  Professional and open source implementations of Common Lisp are
  stable but nonetheless under active development.Many hobbyists
  and professionals use Lisp to solve their problems and make
  money.IDEs are in a sorry state. If you're an Emacs user, you'll
  be happy. Otherwise, unless you spend hundreds of dollars for a
  professional IDE, you won't have much. Editing Lisp requires a
  good IDE.
 
    oblio - 4 hours ago
    Any recommendations for a Lisp IDE outside of Emacs?Also,
    aren't there any other OSS or free Lisp IDEs outside of Emacs?
    Or are they all crap?
 
      fiddlerwoaroof - 3 hours ago
      Also, from a _very_ quick test, it looks like Atom has ok
      support for SLIME.Just grab the latest release from
      https://github.com/slime/slime/releases Install atom-slime
      and sbcl (something like brew install sbcl on osx) Point atom
      to the directory you extracted slime to and then hit packages
      > slime > start
 
      girzel - 3 hours ago
      I wonder why there aren't more good IDEs for Lisp. Is it just
      because Emacs is already there? It seems like it would
      actually be easier to create an IDE for Lisp than for other
      languages. Parenthesis editing should be very simple, as
      should sending definitions to the running system... Is it
      more complicated than I think?
 
      tnecniv - 4 hours ago
      Pretty much everyone I know that does lisp uses Emacs +
      SLIME.
 
        oblio - 4 hours ago
        :(
 
      fiddlerwoaroof - 4 hours ago
      vim + slimv is a pretty good combo, if you're used to vim.
      Also, although it won't give you the "full lisp experience",
      using something like parinfer or paredit in Atom will make
      editing lisp more pleasant.
 
    [deleted]
 
    guicho271828 - 4 hours ago
    just look at slimv
 
  kronos29296 - 5 hours ago
  Haskell is the pureset functional language. If you want to learn
  the principles behind the functional programming paradigm learn
  haskell but its hard. The effort is worth it. But there are
  situations where the performance is worse compared to other
  languages but it is the best place to learn FP.If you are hacking
  on stuff or doing it as a hobby, learn Scheme. Something like
  Chicken Scheme is good. Small concise language but a great
  scarcity of libraries. If you want a pretty ide for scheme or
  write your own scheme use Racket.If you want production code in
  lisp with good library support use Common Lisp. Clojure is better
  because of better functional programming features than CL but
  debugging requires knowledge of Java as it runs on a JVM but the
  plus is you can seamlessly call java libraries which are numerous
  (more than what is in CL).OCaml is functional programming with
  Objects. It it used where there is a need for performance like
  compilers with the advantage of a functional paradigm. But OCaml
  is a pain to work with for any Non Unix systems. F# is functional
  programming for dotNet. Then there is Scala which runs on JVM
  like Clojure and so has the same pros and cons except Scala is
  closer to OCaml and Haskell than to Lisp.(ML family)Depending on
  your platform make your choice. OCaml is horrible for Windows.
  Haskell works. Scala and Clojure just need java so platform makes
  no difference. Schemes mostly have an interpreter for most
  platforms. Make your choice.
 
    ScottBurson - 2 hours ago
    > Clojure is better because of better functional programming
    features than CLCL now has [shameless plug] an excellent
    functional collections library, FSet [0].  Using FSet greatly
    expands the range of algorithms that can easily be written in a
    functional style.  It's been a while since I looked at Clojure,
    but my impression is that FSet has a substantially richer API,
    including a bag (multiset) type and many more operations.I
    don't know exactly which Clojure features you have in mind, but
    I suspect that FSet makes CL at least as good for functional
    programming as Clojure.[0] https://github.com/slburson/fset