
Novice CL user writes mysql access in CL as an exercise - wglb
http://article.gmane.org/gmane.lisp.lispworks.general/9622
======
mark_l_watson
That looks pretty good. A great way to learn a new language: write something
useful.

~~~
bgray
Yes! Writing something significant is a great way to learn a language. I have
also learned a great deal from solving the Euler Project problems. Either way,
just get your hands dirty!

------
wglb
By way of Zach Beane: <http://xach.livejournal.com/238408.html>

------
jacquesm
The list of questions attached to the article suggests an excellent reason why
re-implementing something like this as a novice to a platform is a bad idea.

I've been guilty of exactly that (in java, a persistence layer for classes)
and was rightly shown why that is not a good thing to do. Too many edge cases
and a serious maintenance problem in the longer term.

Before you know it you are maintaining your database connector more than you
are your original reason for writing it (the problem that needed to be
solved).

I'm not too familiar with the common lisp ecosystem but there is a reason why
there are N reasons of doing things there, all of them with varying degrees of
feature overlap and stability.

Unless you have a really good idea on how you are going to move the field as a
whole forward by re-implementing something your time is _likely_ (but not
always!) better spent by improving a solution already out there than by
writing another partial implementation from scratch.

The first few weeks of progress on anything new it always seems like you're
literally on a roll, after that the slowdown comes and the hard work begins.

~~~
tjr
I would agree that releasing it and maintaining it as a real (even if open
source) product would be a huge task, especially for a novice, but I got the
impression that his goal was just to build something for the purpose of
learning more about Lisp programming.

------
rbanffy
That's something I have been observing with some languages.

Perhaps there is a point it's so easy t build useful stuff that the ease
builds fragmentation. If ít's easier to write a new library than to adapt to
one already existing, you have a situation where everybody just writes new
libraries from scratch. The easier to write, the more fragmentation you get.

Keeping fragmentation low requires effort.

