And here is mine (marked "frgo"):
Lisp Makes Business Sense
=========================
I worked with a team of engineers for a telecom company. We were
maintaining a cell phone billing software. Being a very complex
software it took many hours to start.
frgo: Really? Hours to start? Wow, even SAP starts within a couple of
minutes ...
I remember my colleagues working overnight to fix a bug. Imagine the
stress they endured while the company was losing millions of euros.
Now imagine if they were able to find and fix the said bug without
having to restart the software? It sounds too good to be true,
doesn't it? However it's possible with Lisp.
Let me show you a simple example:
(defun hello ()
(message "hello")) ;; frgo: This is not consistent, as I think you
;; are fully aware. #'message not being
;; defined ...
(hello) => "hello"
(defun hello ()
(message "bonjour"))
(hello) => "bonjour"
Do you see what I did? I redefined a function without rebooting my
software. That is really cool! I don't have to waste time compiling or
wait for the program to start. As I improve a function I just need to
evaluate it to try it out.
This is not unique to Lisp. Smalltalk does it too and nowadays it can
be done with any language that uses a symbol to define a function.
However Lisp is so powerful it can even redefine class instances on
the fly.
Let me define two classes to illustrate this:
(defclass class-one () ())
(defmethod method-one ((x class-one)) "I am class 1")
(setf interface-one (make-instance 'class-one))
(member-one interface-one) => "I am class 1"
frgo: Which of course should say
(method-one interface-one) => "I am class 1"
(defclass class-two () ())
(defmethod method-two ((x class-two)) "I'm class 2")
Now I inherit class two of class one. Note that I have no changed the
interface one in any way:
(defclass class-one (class-two) ())
(method-two interface-one) => "I am class 2"
Of course the first method works as expected:
(method-one interface-one) = >"I'm a class 1"
My guess is other language can do this but it would be very difficult to
implement. Indeed a class can be redefined in C++ but existing
instances will behave according to the old definition.
frgo: This is unclear in its message. What has this to do with class
redefinition? (also, English spelling not ok)
The usual critics of Lisp I hear from my colleagues is that it's a
functional language and encourages recursion.
It's partly true. But what is wonderful about Lisp is that it
is multi-paradigm. If you want to do loop instead of recursion fine,
there are constructs such as do, dotimes and loop. If you are more of
a functional programmer you have everything you need map, reduce,
anonymous function, etc... For object oriented programming there is
the Common Lisp Object System (usually called CLOS).
Finally you can program Lisp with macros. Unlike their C counterparts,
they are ways to reprogram the language itself.
I hope I have showed you that things can be done in Lisp that are
difficult to implement in other languages. Now I want to convince you
that not only Lisp is a good technical choice, it also makes business
sense.
Let's get back to my experience at the telecom company. When your
software breaks it's expensive. Doing the usual fixing, compiling
testing is fine for small programs. However when you have critical
enterprise grade software running it is just unacceptable.
Let's see a real world example. Ron Garet observed a team fixing Deep
Space 1 using Lisp. I think his quote is worth meditating on:
"Debugging a program running on a $100 million piece of hardware that
is a 100 million miles away is an interesting experience. Having a
read-eval-print loop (1) running on the spacecraft proved invaluable
in finding and fixing the problem."
If the NASA has put Lisp on a very expensive spacecraft then it is
capable of running your software in an enterprise environment.
When you are dealing with software it would be a benefit when your
engineers learn Lisp. There will be a lot of reticence. After all,
programmers are very fond of their language.
But let's face the truth. It makes sense for your business to spend
less time troubleshooting software in production. You can't afford
losing time and money on critical software.
I hope I have convinced you that Lisp is worth a shot. There are two
books I recommend: The Land Of Lisp by Conrad Barski and Practical
Common Lisp by Peter Seibel which is available as a free download.
frgo: Ok, so by here you have spent 3 minutes with your presentation. If
that's all the time you have the fine. If you have more time then it
certainly would serve your agenda to promote Lisp with some killer
examples that are business relevant: Transpose the NASA example to some
web site running a shop, to some software controlling e.g. a power
plant (but please don't go nuclear here ;-) - or even just a power
transmission grid control software. It would certainly be very nice to
see some examples scling from small to big to show applicability to
every size of business and every type of business.
Just my 2 cents.
Frank