|
If I ruled the universe, Lisp would be the future of programming. I've been re-learning it (only previous experience was some embedded scheme scripting language) to find that it is utterly amazing.
You write in a high-level language, that you insert immediately into your lisp environment. That function gets COMPILED to machine code so that it runs at virtually the same speed as C, yet it is faster to write software than java (the memory usage for Lisp is closer to java than C though). In your lisp environment, you can update functions on the fly. For example, in a transaction processing system, if some transactions didn't process (due to a bug, or whatever), you could stick them into a list (remember, we have lists, hashes, and multidimensional arrays as first class objects) in your exception handler (which allows you to continue after an exception, and not just bail out to after the exception handler), fix the bug in your function, and reprocess them, all without restarting a single system, or having a second of downtime.
Lisp also has an extremely powerful macro system, which is written and evaluated in lisp. Which is a big gain when compared to the C/C++ preprocessor that looks nothing like C. You never know how much you really like macros until you don't have them (Java, PHP, etc). Function calls also have one thing that I wish other systems would implement prono (perhaps something else does): named optional arguments. Say you want to call a function, and it needs two things all of the time, but sometimes you will want to pass it some extra formatting stuff, or other times you will want to pass it some extra key data. In lisp, you can just hand it through as named options, if they aren't there, it's not a big deal, but you can add one or both (or however many) of the optional arguments by name, no more filling in a blank spot, or creating a million polymorphic functions that just fill in the blanks for you.
It's amazing how far technology has stepped back in the last twenty years, now that you look at it.
|