Please create an account to participate in the Slashdot moderation system

 


Forgot your password?
Close
typodupeerror
×
Programming IT Technology

A Video Tutorial of SLIME 50

Posted by timothy from the no-really-that's-the-name dept.
An anonymous reader writes "Ok, maybe I exaggerated a bit with the subject; however, you can check it out for yourself and decide. Marco Baringer has published a video (.mov available for the bittorent impaired) showing off the Common Lisp IDE SLIME. It's a long movie (almost an hour) and provides an in-depth description of many of SLIMES's features which just aren't available (or even possible) in 'modern' IDEs/languages."
This discussion has been archived. No new comments can be posted.

A Video Tutorial of SLIME More

A Video Tutorial of SLIME

Comments Filter:
  • but what I really need is a decent Haskell IDE (that's hopefully not emacs).

    Can anyone point out any strong advantages Lisp has over more modern functional languages? I've been learning Haskell, and really enjoying it, and wouldn't mind another FP language...I was thinking O'Caml, for performance reasons.

    On the subject of those wacky FP languages, here's something I ran across last night, quicksort in 'J';

    qsort =: id ` (($: o selLEF),first,($: o selGTF)) choose notEmpty

    '$' is the self reference operat

    • Re:That's nice.... (Score:2, Informative)

      by Anonymous Coward
      Can anyone point out any strong advantages Lisp has over more modern functional languages?

      -1. (Aside: Lisp can be used for functional programming. It is NOT a purely functional (it does not strive to be side-effect free in everything) programming language like Haskell.)

      0. (Aside: "More modern?" - lisp started a long time ago but has been evolving continuously. The latest Lisp standard is from the 1990s, not the newest standard, but hardly "old")

      1. It's dynamically latently strongly typed with optional sta

      • Re:That's nice.... (Score:1, Informative)

        by Anonymous Coward
        One seldom mentioned but cool other feature: The condition system. Think like exceptions, but when they are thrown, the catcher may be presented with a list of options ("restarts") from the thrower that are the thrower asking the catcher "okay, I'm stuck, which of these should I do, smart guy?", and the catcher can pick one to return control to the thrower, informing the thrower how it is to proceed. This makes dealing safely with external transactional systems much less hazardous, and is great at the int
        • Just to amplify the previous poster's message, I must admit that I had programmed in Common Lisp for some time without completely "getting" the condition system (which is still not terrible as one can trivially use it as a "typical" exception system without its the extra power). I think Peter Seibel really gave me the light bulb moment in Practical Common Lisp. Whereas a typical exception mechanism has two points of relevance in the code, the point where the exception is raised and the point where it is c

      • 0. (Aside: "More modern?" - lisp started a long time ago but has been evolving continuously. The latest Lisp standard is from the 1990s, not the newest standard, but hardly "old")

        Haskell is more modern in the sense that it makes use of more modern ideas in computer science. E.g. lazy evaluation, type inference, pure functional programming, monads, etc. Common Lisp is an old-fashioned imperative language, though it does have decent support for higher order functions and closures, and is perhaps the best O

    • Common Lisp (Score:4, Informative)

      by Julian Morrison ( 5575 ) on Saturday July 30, 2005 @04:21PM (#13203724)
      CL is much "closer to the metal" than Haskell or even OCAML and it's designed to compile to efficient code. As a result it's not particularly "functional" (nowhere near as much as Scheme, for example). CMUCL compiled lisp should approximately match native-compiled OCAML in speed, and CL has an advantage in being a multiple-sourced standard.

      Main advantages of CL

      - Scalable ratio of easy:fast. Prototype lazily and tune iteratively.

      - Macros facilitate "little languages" for task areas, making core algorithms terse and readable.

      - Running apps can be hot-debugged, tested and recompiled in situ.

      - Exception mechanism provides something I've seen nowhere else, namely the ability to catch an exception, repair the problem, and reverse the thow to resume where the code left off.

      Main serious problems with CL

      - Too many fiddly features makes writing a compiler hard

      - Lack of a good standalone-binary compiler.

      - Weakly standardized library mechanism makes cross-implementation libraries unnecessarily hard and hence rare. (NB: "common lisp controller" is a fix for this and standard in Debian.)

      - No fixed standard for foreign function interface (or requirement that one even exist).

      - No sockets or threading in the standard library.
    • It's funny you bring that up because over at lamda-the-ultimate all the Smug Lisp Weenies (TM) have been replaced by Smug Haskell Weenies.

      I'll never dig Lisp/Scheme prefix notation so I'll probably take a look at Haskell or O'Caml eventually.

      Emacs and Vim (I love vim) just aren't suited for IDEs. They're still stuck in a console world no matter what kind of gui is slapped on the front end. Last time I checked Emacs/Xemacs on Unix still didn't have xft fonts, and Vim has so many obscure platforms it suppor
      • Actually, it was reading lamda-the-ultimate that motivated me to learn Haskell. I was sick of reading about all those cool features and having most of it go over my head. I had done some Lisp in school, but didn't grok it at all at the time, probably due to an instructor who couldn't care less.

        That, LTU, and one guy writing a Perl 6 compiler/interpeter in ~3 months convinced me it was worth having a look at.

    • > Can anyone point out any strong advantages Lisp has over more modern functional languages?

      It's multi-paradigm. Compared to the ML family, I'd have a hard time calling Common Lisp functional. Maybe scheme, but I'm not even sure about that. Modern FP tends to revolve heavily around type theory, while lisp only ever tends to use types as a compiler optimization or ala carte when some amount of type discipline is desired here or there.

      Haskell is still nigh unreadable whenever complex state or flow contr

  • Uncommon Web / Slime (Score:2, Informative)

    by uits ( 792760 )

    Marco is the author of Uncommon Web [common-lisp.net], a continuation based lisp framework for web applications.

    Last week he did a video for that, torrent here [common-lisp.net] that was well received. It's still in the early stages, but combined with Lisp-on-Lines [tech.coop] (in development) it's hopefully going to attract some mindshare.

    Bill Clementson also discusses lisp webserver options in his (slighty dated - Oct-2004) blog entry [tech.coop]

    I started working with UCW/Slime/mod_lisp a couple of weeks ago, and I'm pleased to see better getting started v

  • I've never seen a software tutorial in this format, and I think it rocks. From one incomplete, casual viewing, I picked up a couple of features and added them to my repertoire, and I've been using slime for a couple of months. Thanks, Marco!

    I'd like to see more software tutorials in this format. There's something more exciting here than rehashing language wars, guys!

Slashdot Top Deals

Math is like love -- a simple idea but it can get complicated. -- R. Drabek

Close