Late in May, I posed a question about picking Common Lisp or Scheme as
a programming language in the following thread:
http://groups.google.com/group/comp.lang.lisp/browse_thread/thread/96b38d56937d21a7/3026b52f0a718840?fwc=1
A lot has transpired since and I'd like to give those of you who are
interested a little update on what has taken place in the meantime. In
addition to that I have a small followup question.
Let's get on with it then!
Since then, I've finished another book on C#, learned a little bit
more C++, installed Linux (Ubuntu), toyed with it in various ways,
took part in two Ruby (On Rails) workshops, learned about interacting
with the bash shell and its numerous commands, installed a virtual
machine and tested a small OS on it (Damn Small Linux) and read a
myriad of articles and blogs about programming/operating systems/
design/software/tools and related topics. On top of that, I decided to
give Emacs another go. Although I'm still trying to tackle Emacs, my
second encounter with this powerful text-editor was much more
pleasant. It will become my main weapon of choice in battling source
code ;).
**Warning: minor rant**
It dawned on me how the giant cogs of the propietary business churn
(especially MS). Don't get me wrong I haven't become a MS hater
(Visual Studio is a lovely IDE), but rather certain things I
discovered that irked me (like being forced to purchase Windows Server
if you want to run the latest ISS server with more then 10
simultaneous connections, plus making your code interact with non-
propietary equivalents is usually a pain). I feel more at home with
concept of free software/open source (although some propietary mixins
are unvoidable). Plus designing software that's cross-platform always
sounds like a good idea to me anyways :).
**End minor rant **
I'm planning to create a dynamic website for my dad's business (in C#/
ASP.NET). Then move on to learn Common Lisp and write software with
it. I'll try not to neglect C# though, that would be a waste. Since
Lisp is so different from most mainstream languages, I reckon I'll
benefit from it a lot in my quest to become a better programmer.
Oh, in less then a month I'll actually start to study information
technology at the college where I currently work (read: bother my
peers with questions).
That leaves me with one final question. as you all undoubtly know,
Emacs using a dialect called Elisp. I believe I've read that there are
extensions for Common Lisp, but I'm not entirely sure. Do Common Lisp
and Elisp share many similarities, so I can tinker with Emacs?
Thanks for your time and endless wisdom Lispers!
~Meyvn (Arjen Logghe)
Meyvn wrote:
> That leaves me with one final question. as you all undoubtly know,
> Emacs using a dialect called Elisp. I believe I've read that there are
> extensions for Common Lisp, but I'm not entirely sure. Do Common Lisp
> and Elisp share many similarities, so I can tinker with Emacs?
Unlike Common Lisp, Elisp is not a standarized language and I think it
works inside Emacs, only. Maybe the extensions you mean are editing modes
for editing Common Lisp?
Many Common Lisp implementations can be compiled to executables. There are
some other differences, like lexical and dynamic scoping. I suggest that if
you want to use Emacs as your programming editor, use something like Slime
and a Common Lisp implementation for programming in Lisp.
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
+ Frank Buss <··@frank-buss.de>:
| Meyvn wrote:
|
|> That leaves me with one final question. as you all undoubtly know,
|> Emacs using a dialect called Elisp. I believe I've read that there are
|> extensions for Common Lisp, but I'm not entirely sure. Do Common Lisp
|> and Elisp share many similarities, so I can tinker with Emacs?
|
| Unlike Common Lisp, Elisp is not a standarized language and I think
| it works inside Emacs, only. Maybe the extensions you mean are
| editing modes for editing Common Lisp?
I rather suspect that he means the result of (require 'cl) which adds
a number of CL language constructs to elisp. It brings them closer,
but there are still important differences, particularly with respect
to lexical versus dynamic scoping rules, not to mention more advanced
topics like error handling, which is very different, and CLOS, which
elisp completely lacks.
| Many Common Lisp implementations can be compiled to
| executables. There are some other differences, like lexical and
| dynamic scoping. I suggest that if you want to use Emacs as your
| programming editor, use something like Slime and a Common Lisp
| implementation for programming in Lisp.
I second that advice. I wouldn't recommend elisp as a tool for
learning lisp. But it /is/ the tool of choice for modifying emacs'
behaviour (of course), and lessons learned in doing so can sometimes
transfer into the CL world. The trick is knowing when they can't.
Learning to similar languages at the same time can possibly be
confusing. (I bet the same is true of natural languages.)
--
* Harald Hanche-Olsen <URL:http://www.math.ntnu.no/~hanche/>
- It is undesirable to believe a proposition
when there is no ground whatsoever for supposing it is true.
-- Bertrand Russell
In article <···············@shuttle.math.ntnu.no>,
Harald Hanche-Olsen <······@math.ntnu.no> wrote:
> + Frank Buss <··@frank-buss.de>:
>
> | Meyvn wrote:
> |
> |> That leaves me with one final question. as you all undoubtly know,
> |> Emacs using a dialect called Elisp. I believe I've read that there are
> |> extensions for Common Lisp, but I'm not entirely sure. Do Common Lisp
> |> and Elisp share many similarities, so I can tinker with Emacs?
> |
> | Unlike Common Lisp, Elisp is not a standarized language and I think
> | it works inside Emacs, only. Maybe the extensions you mean are
> | editing modes for editing Common Lisp?
>
> I rather suspect that he means the result of (require 'cl) which adds
> a number of CL language constructs to elisp. It brings them closer,
> but there are still important differences, particularly with respect
> to lexical versus dynamic scoping rules, not to mention more advanced
> topics like error handling, which is very different, and CLOS, which
> elisp completely lacks.
http://cedet.sourceforge.net/eieio.shtml
"EIEIO is an Emacs lisp program which implements a controlled
object-oriented programming methodology following the CLOS standard.
EIEIO also has object browsing functions, and custom widget types.
It has a fairly complete manual describing how to use it."
Btw., M-x ielm creates a Emacs Lisp REPL.
> | Many Common Lisp implementations can be compiled to
> | executables. There are some other differences, like lexical and
> | dynamic scoping. I suggest that if you want to use Emacs as your
> | programming editor, use something like Slime and a Common Lisp
> | implementation for programming in Lisp.
>
> I second that advice. I wouldn't recommend elisp as a tool for
> learning lisp. But it /is/ the tool of choice for modifying emacs'
> behaviour (of course), and lessons learned in doing so can sometimes
> transfer into the CL world. The trick is knowing when they can't.
> Learning to similar languages at the same time can possibly be
> confusing. (I bet the same is true of natural languages.)
--
http://lispm.dyndns.org
+ Rainer Joswig <······@lisp.de>:
| In article <···············@shuttle.math.ntnu.no>,
| Harald Hanche-Olsen <······@math.ntnu.no> wrote:
|
|> and CLOS, which elisp completely lacks.
|
| http://cedet.sourceforge.net/eieio.shtml
| "EIEIO is an Emacs lisp program which implements a controlled
| object-oriented programming methodology following the CLOS standard.
Wow. Ain't usenet wonderful. All you have to do is state that
something doesn't exist, and lo and behold, someone comes along and
proves that the thing does exist. This is fun. I'll try one more:
The Riemann zeta function has no zero in the right half plane with
real part different from 1/2.
--
* Harald Hanche-Olsen <URL:http://www.math.ntnu.no/~hanche/>
- It is undesirable to believe a proposition
when there is no ground whatsoever for supposing it is true.
-- Bertrand Russell
In article <···············@shuttle.math.ntnu.no>,
Harald Hanche-Olsen <······@math.ntnu.no> wrote:
> + Rainer Joswig <······@lisp.de>:
>
> | In article <···············@shuttle.math.ntnu.no>,
> | Harald Hanche-Olsen <······@math.ntnu.no> wrote:
> |
> |> and CLOS, which elisp completely lacks.
> |
> | http://cedet.sourceforge.net/eieio.shtml
> | "EIEIO is an Emacs lisp program which implements a controlled
> | object-oriented programming methodology following the CLOS standard.
>
> Wow. Ain't usenet wonderful. All you have to do is state that
> something doesn't exist, and lo and behold, someone comes along and
> proves that the thing does exist. This is fun. I'll try one more:
> The Riemann zeta function has no zero in the right half plane with
> real part different from 1/2.
The trick is to write in in the right newsgroup. Try sci.math . ;-)
--
http://lispm.dyndns.org
On Sat, 04 Aug 2007 13:26:49 +0200, Harald Hanche-Olsen wrote:
> Wow. Ain't usenet wonderful. All you have to do is state that
> something doesn't exist, and lo and behold, someone comes along and
> proves that the thing does exist.
This is a paraphrase of my "rule of internet development", which goes
something like (and which I've observed on many occasions):
1. Think of *anything* (doesn't much matter what).
2. Wait a month or three.
3. Google search for the *anything* of step one (or search engine of
choice).
4. Someone will have built it, and will be offering to sell it to
you.
Cheers,
--
Andrew
On Aug 4, 10:10 am, Rainer Joswig <······@lisp.de> wrote:
> In article <···············@shuttle.math.ntnu.no>,
> Harald Hanche-Olsen <······@math.ntnu.no> wrote:
>
> > I rather suspect that he means the result of (require 'cl) which adds
> > a number of CL language constructs to elisp. It brings them closer,
> > but there are still important differences, particularly with respect
> > to lexical versus dynamic scoping rules, not to mention more advanced
> > topics like error handling, which is very different, and CLOS, which
> > elisp completely lacks.
>
> http://cedet.sourceforge.net/eieio.shtml
> "EIEIOis an Emacs lisp program which implements a controlled
> object-oriented programming methodology following the CLOS standard.EIEIOalso has object browsing functions, and custom widget types.
> It has a fairly complete manual describing how to use it."
It also has a chapter in that manual that amounts to saying the
nonsense about it "following the CLOS standard" is a Big Lie:
http://cedet.sourceforge.net/info/eieio.html#SEC6
Among the things that are broken: :reader, :writer, :default-initargs,
make-instance, multiple dispatch, :around methods, and though it's not
mentioned in that section, multiple inheritance is done wrong.
Thanks everyone for your valuable replies! After I finish the project
I'm working on now,
I'll pick up Peter Seibel's Pratical Common Lisp, and start learning
CL with SLIME.
What about...
http://cedet.sourceforge.net/eieio.shtml
Is this extension recommended? There seem to be some contradicting
views in here.
Regards,
~Mevyn.
Meyvn <···········@gmail.com> writes:
> Thanks everyone for your valuable replies! After I finish the project
> I'm working on now,
> I'll pick up Peter Seibel's Pratical Common Lisp, and start learning
> CL with SLIME.
>
> What about...
> http://cedet.sourceforge.net/eieio.shtml
>
> Is this extension recommended? There seem to be some contradicting
> views in here.
If your purpose is to learn and use Common Lisp, then just take a
Common Lisp implementation.
Nowadays, the communication and computationnal resources are cheap and
abundant enough to be able to avoid this kind of kludges.
If you want X, get X, don't try to do X with Y.
Otherwise, emacs is still an important platform, so if you want to
become an advanced emacs user, it might be worthwhile to learn emacs
lisp, and since it's unfortunately different from Common Lisp, you may
indulge in such things as (require 'cl) and (require 'eieio), but
keeping in mind that this is still not Common Lisp. For Q&D hacks, it
might be useful, since it allows you to keep your CL habits with emacs
lisp. But from here, you have two other options: use an emacs
implemented in Common Lisp (PortableHemlock, Climacs, etc), or use a
Common Lisp implemented in emacs: emacs-cl. Both are not really
naive-user-ready, but if you are a CL hacker, you might have fun with
either.
--
__Pascal Bourguignon__ http://www.informatimago.com/
NOTE: The most fundamental particles in this product are held
together by a "gluing" force about which little is currently known
and whose adhesive power can therefore not be permanently
guaranteed.