Slashdot Mirror

Which is why it makes an easy target for a Scheme compiler, right?

http://github.com/dyoo/moby-scheme
http://planet.plt-scheme.org/display.ss?package=moby.plt&owner=dyoo
http://www.cs.brown.edu/~sk/Publications/Talks/Moby-Bootstrap/

To begin with let's take the computer out of programming Computer Science UnPlugged

There are three environments I'd recommend for teaching programming.

SmallTalk/Squeak coupled with Squeak by Example

Scheme/PLT Scheme coupled with How To Design Programs

Logo/Berkeley Logo coupled with Computer Science Logo Style

The big idea is not to teach them how to do something in one language but to teach them the concepts that will allow them to learn how to do it in any language.

If the kids really are gifted then the class time is too valuable to have them sat there pounding keyboards, that's manual labor. Treat the class as lectures/discussions with experimenting on computers left up to them.

Try and get them to learn about the lectures subject matter before the class e.g. publish a schedule and make it clear they are expected to have read so and so pages before the class.

If they are gifted and motivated this will be as close to the Platonic style of teaching as you can get.

The side effect is that you have prepared them to succeed in college if they can get the idea of using lectures as a review of what they already know.

The PLT TeachScheme! project has a curriculum for teaching programming to high school students, and apparently it's been modified for middle school students as well in the Bootstrap project.

Dip into Ruby (it's not an extension to Java, but there is an implementation that runs on the JVM). The Ruby in Twenty Minutes guide is excellent. There is even a ruby interpreter that runs in your web browser.

Next, dip into scheme. It's a more practical kind of LISP than Common LISP. Get yourself a PLT Scheme with a friendly IDE and tutorials. Play for a while and then go and read about Lambda Calculus :-) Then you can start on Haskell and Erlang etc.

Postscript is a bit domain-specific. FORTH is its grandparent, and much simpler to learn. It's been about for years and there are hundreds of free FORTH systems about. I first learned it when I was 10 on my ZX81.

D looks interesting, but if you have already looked at C and C++, I would strongly recommend looking at Objective-C and contrast it with C++. It's smalltalk-inspired object orientation applied to C vs. Simlua-inspired C++. You will be astounded at the difference. You will also see some similarity with the design of Java...

Most of all, have fun and don't be afraid to start with a quick half hour looking at each one :-) Don't try to become an expert over night. It's taken me 20+ years and I'm still learning, and having more and more fun :-)

You sound like you may be in a good position to understand what the authors of the Scheme Reports mean when they write that "programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary."

Lisp does this sort of thing by trying to find the really fundamental things that must be provided in order to allow you to do anything at all you could ever want. This is why R6RS Scheme has record types, libraries with controlled export, hygienic macros and call-with-current-continuation; if you have these four features, you can build nearly every interesting feature of any other language out there on top of them. Dynamic method dispatch, in the style of object-oriented programming? Easy. Lazy evaluation à la Haskell? Can do. Logic programming, like in Prolog? A few (admittedly a bit hairy) lines of code using call-with-current-continuation, but after that, it's easy to use. Pattern matching? Just a few moderately-complex macros. Synchronous message-passing concurrency? Sure, why not.

This isn't to say that the Lisp world is a panacea, but the languages are more flexible, period.

Go through SICP book. DrScheme is a nice scheme implementation for trying examples in the book. You'll learn to understand some deeper programming concepts, that you problably would not pick up in a few years of random programming practice.

Have you looked at PLT Scheme? I'm not sure it meets all your requirements, but I think it might come close enough. http://www.plt-scheme.org/

You should get modded up...C is a real-world language that's used for real-world problems. It's entirely unsuited for learning concepts other than "how to program in C".

If he's still dead set on teaching C, he should still have students spend a few weeks playing around with Dr Scheme. It's free and cross-platform, so no matter what type of computers are available to students, both at home and in the school's computer lab, their initial runtime environment will be consistant. It's a LISP-ish language, so it was basically designed to be a teaching tool. And students get immediate feedback, much more so than C (which has the intermediary compilation step) and even scripting languages (which require you to save the file before running it).

LISP dialects are great at teaching you to think in a non-linear fashion, which is applicable in all programming environments. If nothing else, exposure to multiple programming paradigms can only improve the quality of the C code that students will end up writing.

exceptions

meh

threads

yeah right whatever

records

can be trivially replaced by lists

associative data structures

such as hashes?

While these aren't into the RnRS themselves (they don't have many reasons to be there either, anyway), saying that Scheme somehow "lacks" these concepts mostly shows that you don't know the language at all.

exceptions

meh

threads

yeah right whatever

records

can be trivially replaced by lists

associative data structures

such as hashes?

While these aren't into the RnRS themselves (they don't have many reasons to be there either, anyway), saying that Scheme somehow "lacks" these concepts mostly shows that you don't know the language at all.

exceptions

meh

threads

yeah right whatever

records

can be trivially replaced by lists

associative data structures

such as hashes?

While these aren't into the RnRS themselves (they don't have many reasons to be there either, anyway), saying that Scheme somehow "lacks" these concepts mostly shows that you don't know the language at all.

Hmmm... you will need libraries and such for that, though some people do use Scheme for all of those things (see http://www.plt-scheme.org/ and http://www-sop.inria.fr/mimosa/fp/Bigloo/). I have personally used it for web applications, though I usually use common lisp and ocaml for that. In fact, if you are looking for an alternative to C++, Java, or Python, I must recommend OCaml. Look at this book. In fact, I wrote an interpreter for R5RS in OCaml...

Actually, I have been carrying around R5RS with me for a while; it will be nice to suck down more print quota on r5r6 (when it is released). Scheme is quite a fun language, though as far as Lisps go, I do prefer Common. Still, for people who want to learn how to program, I generally tell them to start out with Scheme, usually using the PLT stuff, and to look at SICP.

Another possible solution to this problem is PLT Scheme - a functional programming language with an 'IDE' that has a marvelous code-stepper, to watch each step of what happens, and which can be set for levels of language skill - beginner, intermediate, etc., whose error-messages are specific to that skill level. Oh, and it has a widely admired training book, How to Design Programs, as well.

I strongly second that. It is one of the easiest possible languages to learn, and one of the most expressive. It is also a real programming language, not in any way dumbed-down for easier grasping.

I would especially suggest the DrScheme implementation. It has a nice, simple GUI with great features for teaching programming. One of the coolest things in that regard is the ability to use images as objects and actually visually see them represented in your code (a simple example) -- I think that this could be especially great for children who may find understanding the processes demonstrated easier when they see the outcome visually. Also, generating any kind graphics is really simple.

2005: http://icfpc.plt-scheme.org/
2004: http://www.cis.upenn.edu/~plclub/contest/

If you want to see how well you might be able to do in this contest, check out previous problems and how other teams solved them.

"Best reuse of existing code" has been done in at least one programming contest:
http://icfpc.plt-scheme.org/
According to some of the postings on the mailing list it didn't work too well though.

You mean, like the ICFP Programming competitions?
They often exercise a number of different ideals. The most recent one featured code reuse/flexible design as one of the primary goals.

Of course you're almost always going to have some element of coding speed featured in these contests as, well, they don't want to wait a year for the submissions to start rolling in.

More specifically, learn Scheme using SICP. MIT has videos of the lectures, and Berkeley is podcasting both audio and video streams of current class session. There is a free Scheme environment for all manner of OS free and not here

I agree completely with your assessment.

However, instead of a basic variant, how about scheme?

Especially the combination of PLT Scheme
http://www.plt-scheme.org/
which provides a nice interactive environment,
with the book "The Little Schemer"
http://www.amazon.com/gp/product/0262560992/ref=cm _bg_f_2/103-9731106-9419851

The repl can provide you with instant feedback,
you can save code to files and re-run them,
and you can learn about recursive programming!

(display (format "hello world!~%"))

What makes it great for the beginner is that there
are no arbitrary syntax rules to follow, you don't
have to remember the precedence order to decode a***b.

I only wish we still had command line interpreters around. It was so nice when beginners could execute their instructions directly OR add them to a program. It made playing around and learning so much quicker.

Scheme is also a good starter language. Especially PLT-Scheme (DrScheme, MzScheme, etc) which includes a set of teaching packages and texts that take a student from beginning to advanced. It also comes with a nice multi-os IDE with a built in help desk.

Wow... 12 years. Lots has changed since in far fewer years than that!

Maybe you should check out PLT Scheme, a modern scheme interpreter and compiler and IDE, with several "Teachpacks" which help one come up to speed in doing clever things with Scheme. DrScheme is the thing to download, for various platforms.

There are plenty of other Scheme implementations out there, interpreted and compiled.

Personally I do a lot in SCSH, the Scheme Shell which is handy for writing scripts and tools close to the metal on on UNIX/POSIX systems, however PLT and other environments are incorporating more and more of SCSH-like goodies into their libraries, and write stuff that needs to be fast in Chicken or Gambit, which compile Scheme to C. On the Common Lisp front, on a Mac, there is also OpenMCL, which compiles to *particularly fast* native PowerPC code and has a straightforward way of communicating with Cocoa and a number of other Mac-development-friendly features. In fact, all of these implementations have foreign-function-interface abilities which let you call e.g. C functions from Scheme/Lisp, or vice-versa, so you can write performance-critical sections in a low-level language of your choice, and use higher-level languages to develop "smarts".

Here is a graphical simulation of a game that was played. The red guy is the robber, and the blue guys are the cops. There's a key available if you want a better idea of what's going on.

The ICFP is the International Conference on Functional Programming, and the ICFP programming contest is (not surprisingly) a programming contest held in conjunction with the ICFP (the contest specs are usually announced around June -- look for a story on slashdot next summer). However, despite the connection to the ICFP, the contest places no restriction on the languages you can use. Well, I assume they require that your language produce a result that they can run on their testing machines, but that's it.

One of the best known contests is the ICFP (International Conference on Functional Programming) Contest. One great thing about it is that entries can be in any language. Therefore many consider it a competition between languages as much as between programmers.

The winners to the 2005 ICFP contest are set to be announced this month (Sep 27th). Here're a couple of slashdot threads about it:

http://developers.slashdot.org/article.pl?sid=05/0 5/30/036201&tid=156&tid=162

http://it.slashdot.org/article.pl?sid=05/06/26/001 8252&tid=156&tid=8

Try DrScheme. They are at version 299.100 alpha. They've got to be releasing like 50 new versions a year or something!

silly cs majors - the last remaining job will be, of course, to sue everyone else for violating software patents :-)

"In the far-flung future of the year 2000, functional programming has taken over the world and so humans live in an almost unimaginable luxury. Since it's so easy, humans have used robots to automate everything, even law enforcement and bank robbery -- the only job left to humans is to write their robots' control programs." http://icfpc.plt-scheme.org/

Holly hell, ICFP has started.

Go team Perl GO.

http://icfpc.plt-scheme.org/

No language restrictions, very interesting problems. quite prestigious to win. it is great!

The only downside is that it is only once a year. It is fun to do it in a language you don't know as a forced crash course too if you don't expect to win. :)

It starts this weekend! so start preparing.

The judges' prize will be awarded to a team that produces reasonably competitive entries and, in the judges' opinion, has the most effective re-use of their first submission.

I had a similar experience with Common Lisp a couple of years ago. Fortunately I found Scheme, which made the whole functional programming paradigm a whole lot more enjoyable.

http://www.plt-scheme.org/

If anyone is avoiding Lisp and Scheme because of this, make sure to check out PLT Scheme and other Schemes.

Have you tried PLT Scheme? I've heard good things about it, and it may be what you're looking for.

By relying entirely on procedure calls to express iteration, Scheme emphasized the fact that tail-recursive procedure calls are essentially goto's that pass arguments.

If she's interested in programming as an intellectual challenge, I think PLT-Scheme's DrScheme is your tool of choice. I've never used HtDP, but just following the built-in tutorials that come with DrScheme is very instructive. This is especially true if you are willing to set aside the goal of building some particular program. When I get bored, I will occasionally do a problem or two from the DrScheme tutorial. It's much more fun than dumb desktop games like Solitare. Personally, I think of it more as solving puzzles than as "coding." (It's also a Debian package, so life is good.)

If she wants something to tinker with, I suggest getting a little colo box (a UML box isn't too expensive) and hacking around a little with apache, perl, python, shell and web-ish stuff. It's not always strictly programming, but it's a lot of fun and results can be seen without a huge amount of time/knowledge/effort, and she'll have something tangible for her efforts. Well, as tangible as anything in computing can be, anyway.

6) PLT Scheme

:-)

... If you opt to write a frontend for another markup language. I'm serious. The fact is that it would be trivial to add the appropriate functions and macros to transform your markup language into whatever markup language you wish. As a plus, you would also get the full functionality of a programming language! I know that there are a few such libraries available, but the only one that I can think of at that moment is that of PLT Scheme, see their page for details

You might be pleased to learn about PLT Scheme, a free, cross-platform Scheme implementation with a GUI kit based on [a somewhat old version of] wxWindows.

The original poster is unlikely to be interested, but some of the other readers might be... I would recommend PLT Scheme. It is a very complete, powerful, and polished environment for Scheme programming, which includes an interpreter, a compiler, an IDE with project management and a Scheme-specific intelligent editor, an interactive debugger, and lots of powerful libraries including multithreading, high and low level networking, cross-platform GUI-building based on WX, regexes, XML handling, etc. It runs on Windows, Mac, and several Unixes, and is both free and libre. Try it!

What sort of features? How about macros (we're talking R5RS here)? Macros allow you to define new language syntax. For example, if macros were available in C (no, #define doesn't even come close), you could use it to add new language features. Like say, a new type of switch statement that didn't require you to end each case with break.

But what about all the nice features you might find in more conventional languages? You want a nice IDE you say? A GUI toolkit? Objects? You want DrScheme. It offers everything more mainstream languages might offer and more.

Okay, Scheme and it's other Lispy friends might not be the right choice for you, but they're definately worth looking at.

There was a bit of a superior attitude from some of the academics, who feel that languages like Perl and Python reinvent the wheel and neglect the body of academic research by coming up with suboptimal solutions to PL problems that have long since been "solved" in the PL literature. Maybe "frustrated" is a better word than "superior." While I can totally appreciate their point of view, I found myself cringing in embarrassment once or twice when a harangue by one of the academics went a little overboard. There has already been one post on the LL1 mailing list that I feel crossed the line.

The discussion came to a bit of head during the (very interesting) "Worse Is Better" panel (based loosely on the writings of Richard Gabriel), which centered on the question of why the most popular languages aren't the "best" ones.

Like I said, though, it was mostly very congenial. Ultimately, I think each camp took something away from the encounter: both new-found implementation techniques, and a greater knowledge of and interest in the other community. There are some practical issues that the Perl/Python guys have to deal with (e.g., interfacing with legacy languages like C) that aren't really addressed by academics, and I think it was great that these issues were brought to light.

The LL1 website, if anyone is interested, is ll1.mit.edu.

Check out DrScheme from the PLT group. It's "an interactive, integrated, graphical programming environment for the Scheme programming language". It's cross-platform, released under the GPL, and includes cross-platform GUI support (*nix & Windows), a comprehensive help system, a bunch of useful libraries for graphics, Internet, COM access on Windows, etc., as well as some useful applications like a web server, web browser, Gtk interface, a graphical IMAP mail client, and some graphical games.

The underlying Scheme implementation, known as MzScheme, includes a fast interpreter as well as a compiler that can compile to bytecode or native code.

Don't get me wrong: those systems had their own share of problems, not the least of which was that they required expensive hardware to run well. They also lacked some of the niceties and safety check of modern programming languages (by which I mean languages like ML, not C++).

So, what can you do? Don't blindly use C/C++ for everything. Those languages have their place, but they require you to spend a lot of time on stuff that isn't related to getting the job done. Learn something new, and learn about the history of all this. Here are some suggestions:

• Learn about functional programming with Haskell and OCAML, and SML/NJ
• Learn about logic programming with one of the Prolog implementations.
• Read up on CommonLisp, Flavors, CLOS, and the Lisp Machine Window System. You can get CommonLisp implemenations at cons.org
• Read up on Scheme and get a Scheme programming environment. PLT Scheme looks pretty good.
• Read up on Smalltalk-80 and its programming environment (you can get a so-so Smalltalk-80 implementation at Squeak).

While those systems may or may not help you in your day-to-day work, they teach a lot about what programming can be.

For your day-to-day work, consider using languages and environments like Python, Perl, and Java. They aren't quite as convenient as the more academic systems I mention above, but they still let you focus much more on the problem rather than the mechanics of programming.