Re: [ooc-compiler] Dead or just comatose?

[Stewart G. <sgr...@ii...>]

Michael van Acken wrote:
[...]
> regarding the Python documentation: it took me years to get to a
> decent hit rate when looking things up.  For some reason or other,
> I was always looking at the wrong places first for a particular piece of
> information.  The docs and my brain seem to be structured along
> different lines ;-)
> 
> Just yesterday I read a nice article "Strong Typing vs. Strong
> Testing" http://docs.google.com/View?id=dcsvntt2_25wpjvbbhk
> With Python and Clojure I do not miss static type checks at all.
> Both have their ways to make up for it.

Hi Michael,

Interesting article, but I'm not sure I agree with the conclusion: "what 
we need is strong testing, not strong typing." Its true that testing 
pick up some errors that static typing would otherwise have picked up. 
But what we actually need is strong testing AND strong typing. Static 
typing allows us to define a "contract" which the compiler can help 
enforce. As well as ensuring correctness, it also helps to document 
code. Without some static guarantees, APIs are really hard to navigate.

>> What sort of things are you doing with Clojure?
> 
> I've done a lot of web application stuff, both at work and in private.
> Libraries like compojure and hiccup make server side request parsing
> and HTML generation trivial.  Also a big boon: for development one
> can set up things so that functions can be replaced in the running
> server, from within the editor.  With this, the turnaround time from
> changing a function to running it for new HTML takes a fraction of a
> second.  Btw, the package management done by leiningen or cljr is
> great: a trivial interface towards the user but able to resolve all package
> dependencies in the background.  With this I really appreciate the
> wealth of Java libraries available.  For example, it took me three
> minutes to get an OpenGL demo up and running on a laptop where
> no Clojure was installed beforehand.
> 
> The other stuff I've done is database access (Oracle and CouchDB),
> 3D graphics (just a few days ago I implemented shadow mapping
> for OpenGL using penumbra, something I wanted to do since I toyed
> with OpenGL under Python), data analysis (unsurprisingly, Clojure
> shines at list processing), and by now even general scripting
> (although the JVM has a rather long startup time).

Sounds neat. The JVM is a good platform with so many implementations and 
libraries around. For some things it can be quite inefficient as its not 
possible to allocate objects on the stack or in arrays. I used to do 
some Lisp programming myself, and learned  a bit about implementing 
interpreters from studying different LISP implementations (eg. xlisp).

Cheers,
   Stewart