As I accrue experience in repairing and improving legacy systems I find myself approaching code-cleaning efforts with increasing urgency.  Many developers seem to understand the value of producing well-formatted and organized code, but it seems few comprehend the danger keeping unused code.  This is especially true when your system heavily uses reflection and declarative code.

“Code is your house, and you must live in it.” – Michael Feathers

As I accrue more experience

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

First off, here’s the hardware I am working with: Dell Optiplex 755 (love that model #, use it all the time with chmod), ATI Radeon HD 3450, Dell E170Sb 17″ monitor, Dell E228WFPc 22″ monitor.

I first tried to install Ubuntu from a live CD, but the image disappeared after the splash screen…sad times.  So, disconnected the monitors from the ATI card and used the onboard video to get through the install.  Once done with the install, I started researching into problems with ATI cards such as mine.  Fortunately, I found a super-helpful site here: https://help.ubuntu.com/community/RadeonDriver.  I found that there were problems with the proprietary drivers, so I elected to use an open source variant.  It looks like there’s no 3D acceleration for my card, but what do I care (I’m not using it for games or animation).

On the community site I’d read, “You can often just take away your xorg.conf and it will run fine.”  So, this is what I did on my first run.  I followed the site’s instructions for installing the new drivers.  Here they are in short:

1. Get your graphics card info: lspci -nn | grep VGA
1.1. Should return info including the BusID, device type, and card model.  If you get "None known." you are stuck with the "fglrx" driver.
2. Remove the "fglrx" driver if it's already installed: sudo apt-get remove --purge xorg-driver-fglrx
2.1. If anything was removed, reboot after removal.
3. Check to see if libGL.so from ATI is still in /usr/lib ( ignored this and went ahead with the reinstall in 3.1.1.): glxinfo | grep vendor
3.1 If you see ATI under the 'OpenGL vendor string" then you'll need to reinstall the OpenGL libs.
3.1.1. To reinstall: sudo apt-get install --reinstall libgl1-mesa-glx libgl1-mesa-dri
4. Ensure that "fglrx" is not listed in /etc/modules: sudo cat /etc/modules
5. Ensure that "fglrx" is not listed in /etc/X11/xorg.conf
5.1. On my first from, I just renamed xorg.conf to bu.xorg.conf to remove and backup.

After all this, I was able to get my dual monitor setup to work with my card.  This was awesome, but since my 22″ monitor’s resolution was throttled and looked ugly.  I was stuck at 1280×1024.  This was ugly encough to have a go at the X11 config, which turned out to be far simpler than I had thought.  Now everything is working like a charm!

Following is what I ended up with in xorg.conf:

Section “Monitor”
    Identifier    ”Configured Monitor”
EndSection

Section “Screen”
    Identifier    ”Default Screen”
    Monitor        ”Configured Monitor”
    Device        ”Configured Video Device”
    SubSection “Display”
        Virtual    2960 1050
    EndSubSection
EndSection

Section “Device”
    Identifier    ”Configured Video Device”
EndSection

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

Fortunately, there’s an even better alternative, JD: http://java.decompiler.free.fr/.  JD is available as either a standalone UI or a plugin for Eclipse (which is a bummer since I only use Intellij).  This simple little tool has been pretty useful, but I still wish the Java world had something like the Lutz Reflector.

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

Hats off to University of Maryland for this nifty little tool (does not require Intellij).  Findbugs does static analysis of your projects and identifies patterns for bad code.  General categories it includes are malicious code vulnerabilities, performance issues, “dodgy” code (dead code, abuse of statics, etc), correctness issues, experimental (not totally sure what this one is yet), security issues, and threading issues.  The integration with Intellij is pretty slick and I expect to get a fair bit of milage out of this tool (plugins also exists for NetBeans and Eclipse).

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

How many times have we heard this response when we press our co-workers to test the code they are writing.  This argument is often made when the team is up again tight deadlines and excessive pressure from management for delivery.  I’ve even made the argument myself before, but find it increasingly harder to say it with a straight face.

Way back in 2000 I was given a copy of “Extreme Programming Explained” as a going-away present.  I was leaving a research organization here in San Antonio to cut my teeth with a local start-up.  Our shop was reasonably mature (rated CMM-3) and I had learned quite a bit about Software Engineering in a relatively short period of time.  That said, the ideas in this books really got me thinking…and it seemed to help sate my hunger for a more lightweight process that would better fit my now environment.

Among the first practices that I started to grapple with was testing.  I had experience with SilkTest, but I wanted tests that were closer to individual units.  I first started with my own home-made test fixtures and had limited success…a few years later I was using VBUnit and NUnit..and I was becoming test infected.  In spite of my love for working with tested code, I still found myself arguing that I didn’t have time to test when under the gun.  It was about the 4 year mark that I began to shift my view.

Now, I think that abandoning testing due to time constraints is reckless and irresponsible.  I sometimes catch myself thinking that I don’t have time for test writing, but I soon find myself proving this argument wrong.  Often people who don’t have time to test will waste hours debugging code that they are desperately trying to force into production.  This code ends up being brittle and costly to produce anyway.  Corners cut on testing ultimately translate into a more costly investment in debugging and code fixes.  When recently confronted with a peer who claimed that they didn’t have time to test, I angrily responded that I spent two days trying to get code working that was breaking due to a careless mistake in their code (which I then had to help debug).  They didn’t have time not to test!

Granted, learning to test adequately is not a trivial task and can sometimes take years to really get right.  This effort (and investment) is well worth the trouble as it will not only produce better code, but will most often transform how the programmer sees code.  Although I sometimes have to work pretty hard to “tame” legacy code, the investment rarely proves to be wasteful…rather it saves time and money.  Testable code is maintainable code.  Maintainable code is cheaper code.  As developer teams become better at testing they also become better at producing quality code.

Ultimately, I don’t believe that anyone doesn’t have time to not test.  Degrees of coverage may vary due to time constraints, but the value of tests remain constant regardless of deadlines.  A simple test for a possible exceptional case can avoid days of fretting over a rare NullPointerException in production.  Tests have saved me countless hours of time while writing C, C#, Java, JavaScript, and LISP code.  Tests have girded me with incredible confidence in the code I was delivering (within reason, of course…lol).  Everyone should have time to test (the complex code at the least).

After about over a decade of coding professionally I’ve settled on the credo: “No tests, no trust”.

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

First off, what’s with adding “module: ” as a delimiter for the module name and the test?  It used to be “$”.  Well, I’ve been using it with a BDDish convention and this feature finally got under my skin.  I checked the current version of testrunner.js and it seems to be unchanged.

Simple change:

function test(name, callback) {
	if(config.currentModule)
		name = config.currentModule + " module: " + name;

became:

function test(name, callback) {
	if(config.currentModule)
		name = config.currentModule + " : " + name;

Next, I was a little dismayed that we had ok() but no not_ok() and equals() but no not_equals(). There was also no assertion for is_null, not_null, is_undefined and not_undefined (strict for both).
To fix this, I first created the functions I wanted in testrunner.js (I re-used ok for most of these…may do something more intelligent with the messages in the future, ok just sends (no message) if none is specified):

function not_ok(a, msg) {
    ok(!a, msg);
}
function not_equals(actual, expected, message) {
    push(expected != actual, actual, expected, message);
}
function is_null(a, msg) {
	ok(a === null, msg);
}
function not_null(a, msg) {
	ok(a !== null, msg);
}
function is_undefined(a, msg) {
	ok(a == undefined, msg);
}
function not_undefined(a, msg) {
	ok(a !== undefined, msg);
}

** This was all done in the function test(name, callback) in testrunner.

Then, I had to add this to the section where the ‘window’ object is extended (see code follofing comment: // public API as global methods):

$.extend(window, {
   test: test,
   module: module,
   expect: expect,
   ok: ok,
   not_ok: not_ok,
   equals: equals,
   not_equals: not_equals,
   is_null: is_null,
   is_undefined: is_undefined,
   not_null: not_null,
   not_undefined: not_undefined,
   ...

Now I got the assertion methods that I wanted in the first place! I hate mucking with the internals on the testrunner.js file, but the symbol “config” is hidden so I couldn’t define not_equals externally. It would require mucking with the internals in any case.

Well, hope that’s of interest to someone out there. It was simply too much fun not to share.

———————————————————

Oooh, and I’d be remiss if I didn’t include my tests, right?

        $(document).ready(function() {

            module(“when using assertion extensions”);

            test(“should support not_ok”, function() {
                not_ok(true == false, “contradiction, should be not_ok”);
                equals(true, false);
            });

            test(“should support is_null”, function() {
                var testVal = null;
                is_null(testVal, “should be null”);
            });

            test(“should support not_null”, function() {
                var testVal = “null”;
                not_null(testVal, “should not be null”);
                not_null(undefined, “undefined is strictly not null”);
             });

            test(“should support is_undefined”, function() {
                function testFunc() {}
                is_undefined(undefined, “obviously undefined”);
                is_undefined(testFunc.method1, “also undefined”);
            });

            test(“should support not_undefined”, function() {
                function testFunc() {}
                testFunc.method1 = function() {};
                not_undefined(null, “null is not undefined”);
                not_undefined(testFunc.method1, “also undefined”);
            });
           
        });

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

I’ve been using WebTest on Fitnesse for a while but had issue when trying to use it on my Mac.  I found that the problem was with the Selenium server jar.  You have to hack the jar to get it up and running, but the hack is pretty simple.  Here’s a URL detailing what must be done:

http://www.spacevatican.org/2008/9/27/selenium-and-firefox-3

For my own benefit, I’ll reiterate what the other blog stated.  First off, here’s the symptom.  When you try to bring up an instance of Firefox 3 through WebTest (or Selenium test via Fitnesse) you’ll notice that the running Selenium server instance freezes.  If you are running the Selenium server in a Console/Terminal window, you’ll see the following:

Preparing Firefox profile…

The source of the problem is in the *.rdf files inside the jar.  The Selenium (0.9.2) folks hardcoded a version ceiling for Firefox at version 2.0.0.*.  This was a bit of a rude discovery, but I’m ever grateful to the referenced blogger for pointing this out.  I thought it was a Mac thing, but once I finally got a Windows VM running I saw the same behaviour.  The fix is really simple.

Step 1: Extract the files needing change (from the directory where you have the jar).

jar xf selenium-server.jar customProfileDirCUSTFFCHROME/extensions/readystate@openqa.org/install.rdf
jar xf selenium-server.jar customProfileDirCUSTFFCHROME/extensions/{538F0036-F358-4f84-A764-89FB437166B4}/install.rdf
jar xf selenium-server.jar customProfileDirCUSTFFCHROME/extensions/{503A0CD4-EDC8-489b-853B-19E0BAA8F0A4}/install.rdf 
jar xf selenium-server.jar customProfileDirCUSTFF/extensions/readystate@openqa.org/install.rdf 
jar xf selenium-server.jar customProfileDirCUSTFF/extensions/{538F0036-F358-4f84-A764-89FB437166B4}/install.rdf

Step 2: Change the max version in the rdf (Resource Description Framework) files.

The line of interest looks like this: <em:maxVersion>2.0.0.*</em:maxVersion>

* you can change this to 4.*, should buy some time.

Step 3: Update the jar with your changes.

jar uf selenium-server.jar customProfileDirCUSTFFCHROME/extensions/readystate@openqa.org/install.rdf
jar uf selenium-server.jar customProfileDirCUSTFFCHROME/extensions/{538F0036-F358-4f84-A764-89FB437166B4}/install.rdf
jar uf selenium-server.jar customProfileDirCUSTFFCHROME/extensions/{503A0CD4-EDC8-489b-853B-19E0BAA8F0A4}/install.rdf 
jar uf selenium-server.jar customProfileDirCUSTFF/extensions/readystate@openqa.org/install.rdf 
jar uf selenium-server.jar customProfileDirCUSTFF/extensions/{538F0036-F358-4f84-A764-89FB437166B4}/install.rdf

That’s it, once that’s changed you should be good to go for testing against Firefox 3!

Now getting (0.9.2) to work with Safari…I’m still figuring that one out.  I tried using {*safari} for the browser, but it hangs.  I may need to try to use the 1.0 version of Selenium server once it’s released.

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

Sniff…sniff…I think I’m in love…

 http://www.youtube.com/watch?v=T3iryBLZCOQ

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

So, what’s a closure and why should I care?

As Bob Dylan said, “…the times they are a changin’.”   The strange world of functional programming, once restricted to more esoteric languages such as LISP, Erlang and Haskell, is now invading the mainstream.  Languages such as C# and Java are now incorporating concepts once unique to functional programming languages.  These changes should bring simplicity to these more mainstream languages, but I find they are often misunderstood (by myself for certain) and thereby misused or not taken advantage of.  I’ve had a fair understanding of closures for a while, but wanted to develop a more solid understanding, ergo this post.

One aspect of functional languages, called closures, have been talked about since .Net 2.0 came on the scene.  Of course, what many presented as closures in 2.0 really weren’t — for a number of reasons that I don’t care to get into at this time.  More recently with the 3.0 framework (and the same will hopefully be true with Java 7), we see the introduction of lambda expressions; and finally have true support for closures (remember, not all anonymous functions are closures).  You may ask, however, what the heck are closures anyway?  Well, I’ll do my best to give an accurate illustration.

First off, what are they.  As the Wikipedia link above stated, “a closure is a function that is evaluated in an environment containing one or more bound variables.”  Neal Gafter, during a Google Talk given in January 2007, put it another way by saying that a closure is “a function that refers to free variables in its lexical context.”  We all should know what functions are…they are constructs that take a number of parameters and return a result (this includes more than just returning void).  A free variable (or bound variable) is defined as a name (or symbol) that has a definition outside of the closure itself.  The “lexical context” can be thought of as the context of the caller.  I’ll give an example later.

One thing that I found particularly interesting about Gafter’s presentation was how he helped define closure by describing what they should support.  Among other things, he mentioned that closures should have access to private members of the “lexical context” in which they are used.  In C# and Java, they can also access the “this” instance of the caller.  They should also support return values and support throwing exceptions (the latter is more of a Java concern).  He also pointed out that although they are executed within the context of the caller, they can only return control to the caller (and not force the caller to return). 

Gafter also pointed out that closures — as proposed in Java at least — are methods that act as new statements in the language and can be used to extend the native API (he calls these “control abstraction”).  He described them as “concise function literals” that should behave as built-in statement, such as constructs such as for, while, lock, using, etc. in C# but without the problems associated with anonymous delegates and the like.  Again, they are not anonymous class instances (such as delegates, which are not pointers to methods, but rather classes used to box methods).

Okay, so we have at least a rudimentary definition of closures; now let’s see how they can be useful.  To again steal from Gafter’s presentation, I’ll use a couple of his examples that I found useful. 

First off, what’s one of the problems closures can address?  Gafter was describing a bit of code that was used repeatedly throughout an application at Google to gather run-time performance metrics on various operations.  He argued that closures could be used to extend the native API and offer a more elegant syntax.  Here’s what the code looked like:

Granted this is only 8 lines of code, but only one of the 8 lines relates to the business logic of the application.  The additional code (the other 7 lines) ends up cluttering the code and thereby obscures the surrounding business code.  It would be nice if this code could be replaced by something like this (this would probably be a static method from some util class):

Which with the Java’s proposed new method invocation syntax would mean the same thing as:

Neat, huh?  With this example, the time() function is used in a manner similar to “for”, “using”, and other such operations native to the API.  This is an instance where using a closure could be used to wrap common functionality around business logic in a more sensible way.  Since the time method is a closure, we could also access doSomething() is it was a private method, such as this:

Pretty groovy huh? (pun intended)

From the horse’s mouth…

*WARNING: If you have a burning lack of curiosity or can’t fathom looking at code other than code written in your favorite language DO NOT continue reading.  Reading LISP code without an open mind can lead to a general sense of disaffection and in more extreme cases unreasonable zealotry for your preferred language. 

As stated recently I’ve been digging deeper into LISP lately.  In LISP such features are native (and natural) to the language.  For some reason I tend to think that closures look for magical (as well as cleaner) in LISP programs.  I’ll give another example of closures, but this time with one of the parent languages to all this closure goodness.

So here’s the scenario…which, by the way, is an adaptation of the practical exercise in Chapter 3 of Practical Common Lisp.  In the example I’m writing a simple little application to help break down the living things in my yard into a truncated taxonomy.  Once finished, I’ll be able to look up groups of living things by either kingdom or phylum.  Alternately, I can look up a living thing by name and see to which kingdom and phylum they belong.  Bear in mind I probably would never bother with this in real life…

Setting things up:

First off, I’ll create a global symbol for my collection of living things, a function that creates a new living thing, and a function to add a new living thing to my global collection.  Now I know that I should be using the CLOS, but I don’t want to confuse anyone with slots and whatnot.

That was simple enough.  We see that *living-things* is initialized as an empty list (or null set).  The function “make-living-thing” uses the “list” operator to create a special kind of list called a “property list”…think of it as a hashmap.  The “add-living-thing” function simply pushes whatever is passed to it onto the *living-things* collection (which I’m using as a stack in this case).

Now I’ll walk around my yard and add the living things that I find…

Okay, so I left Bermuda Grass out…most of the grass in my yard is dead anyway.  I can print out the contents of *living-things* and see the raw data:

Now to make things look a little prettier (only a little, mind you), I’ll add a few functions for displaying the data in a more readable format:

And now I have something like this (output is truncated):

And now for something completely different…

Okay, now we are nearing where closures enter the example.  Next I want be able to pull data from *living-things* using a SQL-like syntax.  Don’t ask why, I blame it on too much HQL. 

Since I have only one entity type, I’ll just copy the list passed to the from clause and return it (nothing to it…copy-list came free with Common LISP).  The select statement takes a data source (ultimately using the from function) and n comparison predicates.  The function “remove-if-not” is a Common LISP function that removes items from the list (passed as the second parameter) whenever the predicate evaluates to false/nil (the first parameter).

If you run the code from the comments you get the following:

Here you see the first use of a lambda expression to make an anonymous function (a function not associated with a symbol).  The inner function, getf, is just a getter function that gets the value associated with the symbol :kingdom.  The variable x in the getf is the current list item.  For instance, the following gets the value associated with :kingdom for the first item in *living-things*:

The equal function returns true (T) if the value for :kingdom at x is equal to ‘PLANTAE.  That’s all that there is to the lambda expression…it simply serves as the comparison predicate for “remove-if-not”.  There’s still no closure here…any symbol could be used instead of :kingdom and the expression would still be valid:

See? return NIL, no problem. 

End game…

Now we’ll work on the where clause.  Passing lambda expressions is kind of ugly, though, so we’ll want to create an operator that will handle the where clause.  Once finished, we should be able to make something like the following call and get all the matching entities back:

(select (from *living-things*) (where :kingdom ‘ANIMALIA :phylum ‘ARTHOPODA))

This part gets a little funky because we’re going to use macros.  Macros in LISP are similar to macros in C, but pumped up on steroids.  Macros in LISP are used for run-time code generation (but much more elegant than IL generation in .Net).  I’ll skip over some of the details on macros but will attempt to get at the spirit of this whole thing:

This part’s a little hard to follow.  We are focusing on the “where” macro, but I think we’ll start with the simpler predicate functions. 

Birds eye view: First the “where” macro utilizes the “make-comparisons-list” function to generate a comparison predicate from a set of criteria.  The “make-comparisons-list” function utilizes “make-comparison” for create a part of the overall comparison predicate using a field/value pair (such as :kingdom ‘ANIMALIA).

The “make-comparison” function works just like the lambda function in the example above.  First it gets the value associated with the specified symbol (such as :kingdom) and then checks that value against value that was passed as a parameter.  Here’s where we see a closure, where “living-thing” appears out of nowhere.  First off, the backquote before the list containing “equal” is used to evaluate the list as code, the commas latter in the list mark variables.  Without the backquote and commas we’d have an error because “living-thing” is not a bound variable (and that’s bad).  This backquote facility is very important in that it allows the coder to easily define code that can be evaluated later.  So, if you execute “make-comparison” you get a piece of the code that the macro will ultimately execute.  Again, I’m sure you noticed that “living-thing” isn’t a bound variable…yet.  We’ll get back to that.

Since we want to support more than one comparison predicate, we’ve also created the “make-comparison-list” function with iterates over a list of fields and values (or properties and their associated values).  The “loop while x collecting y” construct is an iterator with an accumulator.  Basically it is iterating over all the field/value pairs (x), popping the field then the value and passing them to “make-comparison”, and finally appending the resulting code (y) to a new list (this is a Common LISP feature).  The result is a list of comparison predicate expressions. 

Here the macro takes everything following the “where” operator and constructs the appropriate of comparison predicates.  The where function will iterate over the list returned from the “from” function and pass each list item to the lambda expression. The variable “living-thing” is introduced as a parameter in the lambda expression, which will be bound by the time the code resulting from “make-comparison” is evaluated (where the closure is).  The “and” function is used for the conjunction between all the comparisons resulting from calling “make-comparisons-list”.  Ideally, I’d use a more generic name for the bound variable used in “make-comparison”, so that I could create predicates for any other property list.

To illustrate the code that’s generated I’ll make a few calls to the function macroexpand-1 (it’s kind of like reflecting over the macro):

So, now you’ve seen the final lambda expression generated by the macro when using both multiple field/value paris and when using only one.  Now we’ll put together the entire select statement and test it…I’ll get all animals from *living-things*.

…and now we’ll select all plants and use the “friendlier” display:

So, as far as using closures, the closure on “make-comparison” was handy for supporting the lambda expression in the “where” function.  I think that LISP is nice to clearly illustrate how closures work.  One doesn’t NEED to use closures…but at times they are quite useful for making code a bit simpler and easier to read.  I hope this post was helpful in elucidating the nature of closures and how they might be used.  I also hope it helps show how fresh a 50+ year old language can be.

For more information on closures:

This article seemed like a decent illustration of their use in C#.

If you can make it through the near 2 hour presentation, Neal Gafter’s discussion of Closures in Java about a year and a half ago was an interesting illustration of what they might look like in Java.  I also used some of his discussion as an example in this article.  (It’s also fun to watch the original crowd of near 60 people dwindle down to about 10 by the end of the presentation)

Then of course there are the scores of books and sites about LISP, Erlang, Haskell, Ruby, JavaScript and other languages that feature closures as a central feature of the language.

Happy Coding!

Joshua

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

It’s hard to convey the value of learning LISP.  I’ve played with Scheme in the past as essentially mental gymnastics…the LISP family really challenges the way one thinks about programming in general.  More recently, the increased popularity of languages such as Ruby has increased interest in functional languages…many of which trace there pedigree back to LISP (which has been around since the 50s).  For you .Net and Java developers out there, the increased importance of functional languages could easily be justified by recent additions to the feature sets of both languages (lambda expressions, closures, anonymous functions…all LISP).

My first experience with the LISP was in 1998 while taking “Survey of Programming Languages”.  As part of the class each student had to start off by writing a paper about any programming language that they wished.  I though that LISP sounded neat and wrote a paper on Common LISP with a focus on the CLOS.  Much to my chagrin, I soon found that our next task was to implement a set of programs in our language of choice.  I began to think that maybe the guys who picked languages like Fortran and Pascal weren’t such idiots after all…in short I was hating life.

My first major hurtle in learning LISP enough to survive the course – by survive I mean earn an ‘A’ – was picking an implementation of LISP.  I found that there weren’t a whole lot of options for my Windows 95 box.  I ended up settling with Harlequin’s implementation, but it wasn’t near as nice as what I’d used for C++.  I delivered my code on time, made the marks I wanted, and then chucked LISP near the dusty bottom of my mind…along with Pascal and numerous flavors of Basic.

Now 10 years later I’ve dug out the language am giving it another go.  I’m now aware of quite a few LISP implementation to choose from and picking the right one for me has been a bit of a chore.  Dr. Scheme was pretty cool, but I really wanted to learn Common LISP…so I finally settled with Allegro CL (for the time being at least).  The IDE choices are equally disappointing, but there are a few reasonable choices.

I’m currently using LispBox, which packages Emacs-Slime-AllegroCL in one nifty little package (Allegro’s IDE is terrible…for my uses at least).  I must agree that Emacs is probably not for everyone.  There are implementations supported by vi as well as a number of commercial products.  For Dev Studio guys the IDE options are pretty depressing.  There are numerous references to an Eclipse plugin called CUSP that sounds pretty good, but I haven’t used it myself.  As far as Eclipse, I’m using Ganymede.  When I tried to install CUSP in the past I was thwarted by a bad URL for the update site…I tried an alternate URL that worked, but wouldn’t run on Ganymede (looks like it was written for Europa).  Dandelion seems to work okay, I just haven’t played with it yet (comes with CLISP implementation).

As far as learning the language itself, I’ve found a couple of sites that did a wonderful job at justifying learning LISP.  Erik Rasmussen did a great job in explaining both the delight of learning LISP and the horror of picking an IDE.  Erik also referenced another article that did an amazing job of describing LISP in terms familiar to C++/C#/Java people…it’s a little long but well worth the read.  My favorite book to date on the subject has been Practical Common Lisp by Peter Seibel.  Seibel’s book is geared toward developers already fluent in another language…so it doesn’t beat around the bush too much. 

Well, that’s it for now…I’ll share what I learn if I think I can present something of value.

Post Footer automatically generated by Add Post Footer Plugin for wordpress.