Slashdot Mirror

I think the Common Lisp community could learn a lot by examining the Scheme Request for Implementation and the IETF RFC processes. Both groups seem to be able to set standards on a semi-ad-hoc basis. With the current hibernation of the ANSI standardization committee, there should be some kind of semi-formal forum to discuss extensions to the language and the standard libraries (e.g. the MOP, Gray streams, SERIES).

Moderators, if you're still here: please mod this up.

> I find talking about LISP as one language compared
> to Java to be a complete joke. Whose LISP? Scheme?
> Whose version of Scheme, GNU's Guile? Is the Elisp
> in Emacs the most widely distributed
> implementation of LISP? Can Emacs be rewritten
> using Guile? What is the GUI framework for all of
> LISP? Anyone come up with a set of LISP APIs that
> are the equivalent of J2EE or Jini?

There are exactly two dialects of Lisp that have relevance to this discussion.

ANSI COMMON LISP is designed for large application development by a large team of programmers. It is the first object oriented langauge to have an ANSI standard. (circa 1990).

Scheme is a minimalist language designed for ease of learning. It is specified by R5RS.

CURL is heavily influenced by Lisp, a language popular among Computer Scientists. A relatively simple dialect of Lisp, Scheme, is used in teaching introductory CS. Improvements from Perl 4 to Perl 5 were inspired by Scheme, as were some current and future Python features. Scheme's syntax is quite different from C, etc., albeit simpler and more uniform.

Kawa Scheme compiles directly to JVM bytecodes, without any intermediate Java-language code. It's quite useful for scripting in a Java environment. I've extended it into the Beautiful Report Language (BRL), a template system like PHP but without the language misfeatures. If you want to get a feel for a Lisp-like language while working in a server-side Java environment, BRL would be a good tool.

In case you missed it, yes, this is a shameless plug. I wrote BRL and use it daily in a professional environment.

I think the reason for the poor code lies more in the shortened development cycle than anything else. The eXtreme camp would say refactor, but usually the conditions that caused the shortened cycle in the first place mean you can't go back. If the conditions are caused by poor project management, that is one thing. Often though, they are brought about as the only means for survival.

Maybe we should just stick with safe languages?

I also take exception with the comp-sci dig =). I think a good comp-sci curricula leads to LESS slipshod code. I've seen too many people reinvent the wheel (poorly) because they didn't understand basic computer science concepts and design. The teaching of which is the goal of the very first class in the curriculum.

So why did Scheme never take off? It is one serious, kick-ass, efficient, clean, compileable gem of a language, and believe me, I've programmed one hell of a lot of languages.

My theory is that Scheme never really took off because of a lack of useful standardized libraries. Utility libraries is really the only reason why Perl is popular, and Python is making tremendous inroads with its ever-growing collection of libraries.

Ruby is suffering from the same problem. People like me do not want to have to write an HTTP parser, binary tree library, socket interface, whatever, Yet Again.

• "Teach Yourself Scheme in Fixnum Days": A comprehensive tutorial
• "The Scheme Language": a shorter tutorial
• "Invitation to Scheme": yet another tutorial
• The Scheme Language Standard, "R5RS", is actually surprisingly readable, at about 50 pages. Here's a PDF of R5RS, which is useful to have around if you're actually using the language.
• The Structure and Interpretation of Computer Programs (SICP) - a.k.a. the wizard book, a very worthwhile and enlightening book, used as an introductory text at MIT. It's available on the web, but it's not a light or quick read.
• How to Design Programs (HTDP) - a book that teach program design techniques, using Scheme.

Scheme Requests for Implementation

Does everybody on slashdot think that the only salient feature of Python is that it doesn't use curly braces?

Get over it!

I am being quite serious. If that modest syntax change is enough to keep you from considering a language, you're doomed as a programmer to linguistic provencialism that will keep you from seeing some really elegant ways to simplify and modularize your code. Ever programmed in Erlang? Haskell? Scheme? Prolog? You might end up preferring a more mainstream language after all is said and done, but the experience of seeing the new ways of doing things will certainly make those mainstream programs better.

You'll never get that experience, though, if you get scared by the syntactic differences between those languages and C (which are vast). So do yourself a favor and try to see beyond a language's syntax.

The Scheme standard is fairly minimal because its main use is in education, and they want it to be easy to implement a complete Scheme. Real implementations generally include things like xor. There's a movement afoot to standardize such extensions among Scheme implementations.

The reason one doesn't totally get used to programming in Scheme even after a semester course is that the course is usually teaching a series of progressively more interesting CS principles, not giving you lots of practice at one level before moving on to the next. You have to use Scheme in real-world work for a while to get the kind of repetition that familiarizes you with the common constructs and techniques.

It's hard to explain in a paragraph or two why functional programming is so great. Suffice it to say that it allows for much more reuse than object-oriented programming, opens up whole new ways of abstracting out functionality, and prevents one of the most common sources of bugs--aliasing.

Not all functional programming languages are purely functional. In fact, many programmers program in such functional programming languages like they do in Perl or Python. That can be both bad and good. On the one hand, because functional programming languages are powerful even for procedural programming, they may never be encouraged to learn how to take advantage of functional features. On the other hand, it may be a good way of getting work done.

My recommendation for people wanting to use a statically typed, efficient functional programming language would be OCAML. It has a full object system, yet also offers a full set of functional programming primitives. SML/NJ is another excellent implementation supporting both procedural and functional programming, and very lightweight threads (as an alternative to objects; cf. the GUI system).

Scheme and CommonLisp are also great languages. As a procedural or OO programmer, you can think of them as Python with a different syntax and a much better compiler. MzScheme is an excellent Scheme system for learning, and Bigloo is a powerful Scheme compiler. You can find more information at schemers.org.

For heavy-duty programming, CommonLisp is still better than Scheme, IMO, but it's significantly more complex. You can find a bunch of implementations at cons.org. I recommend CMU CommonLisp highly. For experimentation, CLISP by Haible is a good small interpreter. There are also a few "scripting" implementations of CommonLisp around.

Haskell is absolutely amazing for distilling programs down to 1/10 or 1/100 their size. However, it really requires a very different way of approaching programming. I'm not sure whether to recommend starting programming with it or not, in particular if you come from other languages.

There are also some special-purpose functional programming languages for high-performance computing. Those languages give performance similar to Fortran or C on numerical problems and can actually be parallelized more easily.

Of course, whether any of these links help you depends on whether you can get started using a new language with a reference manual, user manual, short tutorial, and implementation. If not, there are lots of textbooks around. The Haskell site in particular also has lost of link for FP-related resources. Also search Fatbrain.

So, in summary: functional programming languages are definitely ready for many applications. If you want to get started, there are lots of resources available. Try to find a book that you like and experiment. MzScheme or OCAML are fairly traditional ways of getting started (you still get a lot of the features you are used to from procedural languages). I suspect that functional programming is going to be the "next big thing" in programming after OOP, and I also think it's a lot more useful than OOP and a lot more well-founded.

i really think that Lisp, or better yet, Scheme, is the way to go for teaching kids to program. it teaches algorythms etc, rather than structure (which changes from language to language)

check out www.schemers.org for more information

-------------------------------------------

The TUNES review basically says "the standard sucks because it doesn't standardize half the things that are really necessary." Yep. However, that doesn't mean that there aren't Scheme implementations that do a good job of filling in the gaps. In particular, Rice University's PLT group puts out a Scheme environment, DrScheme, that has everything that TUNES complains about and more (including a good object system). DrScheme is on the short list of Scheme environments to be using. True, it's not standard, and that's a problem. However, it's fairly well-documented (with a graphical help browser, no less, that doubles as a minimal HTML renderer), and it's supported by some of the most prominent Schemers around (in fact, members of the PLT run schemers.org, what TUNES calls the "number one page about Scheme"). They're accessable, too- if you think it can't do something you want to do, post to comp.lang.scheme and one of the maintainers will tell you that you're wrong with a degree of politeness proportional that in your original message =).

Of course, I go to Rice, and I know the people who maintain DrScheme, so I'm biased. However, having programmed in it for two years, I can tell you that if you can't do something in DrScheme, that's because you shouldn't be allowed to do it at all.

There is already a very good programming language which is very well suited for learning computer science, much more so than Python.

There are excellent books for learning this language. E.g. "Structure and Interpretation of Computer Programs"

Yes I mean Scheme.
See:
http://www.schemers.org
The TeachScheme! Project
comp.lang.scheme FAQ