stefano

DrScheme (PLT scheme's IDE) automatically translates [ and ] to ( and ) where appropriate. It's very handy.

You can start by playing with the ASM library. It's a java library to parse, generate and analyze JVM bytecode. Here's the official guide: http://download.forge.objectweb.org/asm/asm-guide.pdf

While learning how to use ASM you will also learn about the instruction set of the JVM. It also includes a disassembler that, given a .class file, outputs the java code necessary to generate that class using ASM.

I agree. It wasn't new, but back then it was an exception, something really different from the norm. Now it's a more common thing. Now it's taken for granted that different languages can target the same VM and interoparate without going down to C.

Different languages hosted on the same VM. Ten years ago if you said JVM the only language to come to mind was Java. Now it's common to think of Clojure, Scala, JRuby, Rhino, etc. too.

My favourite one:

  "It is not the task of the University to offer what 
   society asks for, but to give what society needs.
   
  [The things society asks for are generally understood,
   and you don't need a University for that; the university
   has to offer what no one else can provide.]"

The sad thing is that CS courses tend to go towards the opposite direction.

There is another implementation of Joy, targeting the Parrot VM: http://wiki.github.com/TiMBuS/fun

I don't know C#, but it seems to me that your C# version of memoize works only for functions with exactly one argument, while the CL version works for any kind of function.

PLT scheme comes with an implementation of currying built-in:

  (define add2 (curry + 2))
  
  (add2 5) --> 7

I highly recommend it. I'm building a toy web application in order to learn the Continue web framework. Up to now it is excellent. I've developed using PHP+Codeigniter, and I find Continue to be a lot easier to use (if you know scheme, of course). It is easy to get started, thanks to the DrScheme IDE and the "batteries included" philosophy of PLT scheme, and you can deploy a working executable (including the web server and all the dependencies) with just a few clicks.

I think it's because VML is slow, and probably it misses some features to properly emulate SVG.

Dataflow programming is exceptional for GUI programming, although I've never tried using it in a large application.

This style of programming does its best if it has support from the underlying language to enforce consistency. Without it, it's just too easy to get the program into an unconsistent state.

I'm aware of only two implementations providing dataflow programming: Cells for Common Lisp and FrTime for PLT Scheme (but I've actually used only the former).

I had to learn about the development process, requirements documents, design documents and UML for a software engineering class I took this year, and the project in which we had to apply everything we learned was web-based and written mostly in javascript.

Javascript is actually a quite good language: it has a dynamic object model and real closures. It has its deficencies, of course (like scoping rules).

It's really bad if you prefer statically typed languages, though, because on the client side on the web you have no other choice for the moment. Probably in the future we will see language implementations that use js as a target language become more mature and widespread.

After you take out s-expressions and macros, what's left is no more Lisp. What really sets Lisp apart is the ability to easily manipulate code programmatically.

Most common languages (but not all languages) are basically equivalent, and choosing one or another is more a matter of taste rather than "the best tool for the job". If, for example, you want to write a web app and need to choose between Ruby, Python or Perl pick the one you know best and go with it.

One factor that can make the language choice important is the speed of the program: if you need to make a computationally heavy application, you'd better choose a fast language. This would rule out interpreted languages. In such a case, you should choose Common Lisp/C/C++/Java/C# rather than Perl/Python/Ruby.

Another important factor is the platform where your app will be running. If it's on your own server, you can use whatever you prefer. If it's on the iphone, the most abvious choice is Objective-C. If it's a small device with little memory and low computing power, languages with a low memory footprint and manual memory allocation like C and Forth would make a better choice than Python or Ruby.

What a coincidence. I live exactly in Romano. I'll be back to university in october. If you'd like to go out for a spritz in that period, you may contact me: stefano.dissegna [at] gmail.

Near Bassano del Grappa and currently studying at the University of Padova.

I've found ArgoUML to be quite hard to work with. BoUML is much better.

Why are they so different? Both Self and Unladen Swallow compile two highly dynamic languages just-in-time.

It broke my http client too (written in Arc, btw) some time ago: http://arclanguage.org/item?id=8283

I'd like to see how it compares to Self and SBCL.

There's a compiler for ruby on parrot: http://github.com/cardinal/cardinal/tree/master

It's not under active development, as stated in the project page. So don't expect Ruby on Parrot any time soon. There's always hope for the future, though, considering Parrot's improvements over the last few months.

That could be said for any language. It's just that the first language someone usually learns borrows more from algol than from lisp. This leads to the idea that Python/Ruby/PHP/Javascript are easier to learn than Clojure/Common Lisp/Scheme.

You can. You have two different ways of doing it: the first is to write your own low level opcodes, the other, and I think more powerful, is through PMCs. A PMC (Parrot Magic Cookie) is a basic type of your language (e.g. an Integer, a Char, etc.) with some operations associated to it that you can override. Operations include assignment, type conversion, invocation, your own methods and many more. After writing a PMC you can then "map" it to a core type. As an example, if you write a "function" PMC and map it to Parrot's "function" PMC every time the VM needs to create/use a function, it will use the one you defined instead of the default one. This gives a LOT of flexibility.

  "Although I was unable to use LISP in any production code"

Does he refer to LISP 1.5?

When talking about dynamic languages speed, people tend to take into account only ruby, python, perl and javascript. Common Lisp is at least as dynamic as those, and compiles to fast binary code. Comparing V8 to Ruby is easy. Try comparing it to SBCL.

C++ templates are similar to macros: they run at compile time to generate code, but they're a lot harder to use.

Isn't this similar to dynamic scope?

It is very common in Italian too ("Deformazione professionale").

> As a result, the five million lines of Mathematica code that make up Wolfram|Alpha are equivalent to many tens of millions of lines of code in a lower-level language like C, Java, or Python.

Calling Python a "lower level language" seems quite a bold statement. It makes me want to learn Mathematica just for the sake of understanding why it is higher level than Python.