How did I not find this language years ago ? (or my 'finding lisp')

It's really odd.
One can go through life feeling very clever and up to date, learning paradigms like object oriented programming, grokking new languages (like Python and C#) and getting really good at DB interaction.

Then, a couple of years ago, I took on a contract and ran into a ex-CIO who seemed quite good at architecture. I got talking with him about languages one day and he said his favourite language was common lisp.
I was genuinely surprised and I came out with what I later find is one of the stock standard arguments against lisp, "isn't it quite slow". He said you get speeds approaching C/C++ and more power to boot. He recommended that I have a look at SICP if I was interested in finding out about lisp like languages.

I still haven't finished SICP (still on my list to finish off), but one quote in the foreword really stuck with me

Lisp changes. The Scheme dialect used in this text has evolved from the original Lisp and differs from the latter in several important ways, including static scoping for variable binding and permitting functions to yield functions as values. In its semantic structure Scheme is as closely akin to Algol 60 as to early Lisps. Algol 60, never to be an active language again, lives on in the genes of Scheme and Pascal. It would be difficult to find two languages that are the communicating coin of two more different cultures than those gathered around these two languages. Pascal is for building pyramids -- imposing, breathtaking, static structures built by armies pushing heavy blocks into place. Lisp is for building organisms -- imposing, breathtaking, dynamic structures built by squads fitting fluctuating myriads of simpler organisms into place. The organizing principles used are the same in both cases, except for one extraordinarily important difference: The discretionary exportable functionality entrusted to the individual Lisp programmer is more than an order of magnitude greater than that to be found within Pascal enterprises. Lisp programs inflate libraries with functions whose utility transcends the application that produced them. The list, Lisp's native data structure, is largely responsible for such growth of utility. The simple structure and natural applicability of lists are reflected in functions that are amazingly nonidiosyncratic. In Pascal the plethora of declarable data structures induces a specialization within functions that inhibits and penalizes casual cooperation. It is better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data structures. As a result the pyramid must stand unchanged for a millennium; the organism must evolve or perish.

Strangely enough about 11 years worth of my experience is in Pascal. After discovering lisp, I find large parts of what goes on inside pascal to be very much about building rigid structures and being very careful to think about types. Pascal is good for what it does and is quite useful for relatively simple apps, but to make more complex dynamic software, one ends up writing subsets of lisp in pascal (Greenspuns tenth rule

Since reading that I've come across other quotes from people doing lispy things, this from Rich Hickey who developed Clojure
Discovering Common Lisp after over a decade of C++, I said to myself — 'What have I been doing with my life?', and resolved to at some point code in Lisp. Several years of trying to make that practical, with 'bridges' like jFli, Foil etc, made it clear that bridges weren't going to be sufficient for the commercial work I was doing.

quoted from

The 'what have I been doing with my life?' part of the quote has really resonated with me. With such an amazing language, large chunks of what I've been doing seem somehow wasted when I could have done them with more ease in lisp.

I am starting to sound like a bible salesman, but you get that.

The next trick to pull off will be to use lisp to make some wildly useful tools in the C/C#/Pascal/SQL/HTML world that I live in. Should be fun, though may take some time.

Would it be possible to do this in lisp?

Recently, came across this podcast were Anders Hejlsberg is interviewed.
He talks about how he got into Delphi (via Algol) and then some of the research work he's been doing lately with C# at MS.

Somewhere in the podcast he mentions that creating specific languages in C# would be quite difficult, because it would require tools that would be able to parse statement trees full of code.

I wonder what his exposure is to lisp... I've walked expression trees myself a little in lisp and I've found it quite useful. I imagine I could write myself a whole language if I wanted to (I'm sort of in the process of doing it at the moment).

He also says that using generics made the process of building LINQ into C# a lot easier. I imagine he's right. However, I wonder if lisp might be easier again for this kind of task.

I must sit down on the train sometime and try and write something like a LINQ for lisp. I imagine it would be possible.

At the moment still building my plsql generation language (mentioned above). Now it has a built in type inferencer (courtesy of Pascal Bourgignon sp?).

Downgrading lisp thinking into pascal (Delphi)

Unfortunately this is not really an add for pascal...

On my way to work each morning I grab the little seat under the stairs (when it's free) and enjoy working through learning a bit more lisp code.

I feel like I've learnt a fair bit along the way. Even without macros and CLOS (which I'm not using much yet), I feel like I can get things done so much more easily in lisp (and I'm SURE there is much more to learn).

The things I really like in lisp in comparison to pascal are :-
variables know type, don't worry about type until you need it
automatic garbage collection is quite cool
It's nice to be able to do things while the program is compiled and running that you would normally think only possible while in interpreter "mode" (and to a certain extent the same is true in the other direction).

I keep seeing pages of Delphi code and I think about how I'd do it much more succinctly in lisp.

We are using some reasonable design patterns in code, but I'm pretty sure I could do a nicer job in relatively straightforward lisp.

PS Oddly I wrote something on lisp a few months ago and got an email from a recruiter offering me a Delphi role. I wonder what will happen with this one.

AAAaaaaaargh !!! Emacs has eaten my brain!!!!

I'm a Delphi developer.
This means that a great deal of my time is spent sitting inside Delphi's IDE (which is very pretty).

However, I've spent the last few months doing Oracle and MSSQL scripts and of course, I thought I'd use the editor of choice, Emacs. This has meant that I've got kind of used to doing things like C-x C-s to save the last bit of work that I've just done.

Doing this in Delphi of course means that you get a line deleted and then the file saved (!!!??). This was at first quite frustrating.

I think my coding brain has now become somewhat mulit-IDE-al, so I catch myself now.