CollabRx is hiring brilliant engineers to join our core team in
building a unique and powerful web-based e-science platform focused on
biomedical research. We’re looking for expertise in web development,
knowledge engineering, semantic web, scientific computing, business
process management, and large-scale service-oriented architecture. We
use Lisp, Ruby, Javascript, Java, and a smattering of other
technologies (mostly on Linux). However, specific experience is not
critical! What's critical is a deep interest in science, an
outstanding ability to solve hard problems, a willingness to learn
what's needed to solve them, and the desire to work as part of a team.
We know that Lisp hackers are the smartest engineers in the world, so
if you're a Lisp Wizard looking for a fascinating and challenging job,
and are not afraid to jump into complex problems where you have to
learn new technologies, join us in revolutionizing science!
CollabRx is a well financed startup led by a team with a track record
of significant success in both business and science. We offer
competitive pay, stock options, and excellent benefits. We are
conveniently located in downtown Palo Alto, near CalTrain. We are
currently only interviewing for full-time members of the core
engineering team.
Please contact Jeff Shrager, CTO ((first initial + last name) at the
obvious .com address.))
From: Kenny
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <4867db83$0$7358$607ed4bc@cv.net>
Jeff Shrager wrote:
> CollabRx is hiring brilliant engineers ...
Damn. I am down to "faintly luminescent" at this point with a 3 Kelvin
afterglow not too far off.
to join our core team in
> building a unique and powerful web-based e-science platform focused on
> biomedical research. We�re looking for expertise in web development,
> knowledge engineering, semantic web, scientific computing, business
> process management, and large-scale service-oriented architecture. We
> use Lisp, Ruby, Javascript, Java, and a smattering of other
> technologies (mostly on Linux). However, specific experience is not
> critical! What's critical is a deep interest in science, an
> outstanding ability to solve hard problems, a willingness to learn
> what's needed to solve them, and the desire to work as part of a team.
> We know that Lisp hackers are the smartest engineers in the world, so
> if you're a Lisp Wizard looking for a fascinating and challenging job,
> and are not afraid to jump into complex problems where you have to
> learn new technologies, join us in revolutionizing science!
>
> CollabRx is a well financed startup led by a team with a track record
> of significant success in both business and science. We offer
> competitive pay, stock options, and excellent benefits. We are
> conveniently located in downtown Palo Alto, near CalTrain. We are
> currently only interviewing for full-time members of the core
> engineering team.
>
> Please contact Jeff Shrager, CTO ((first initial + last name) at the
> obvious .com address.))
Would we have to learn Chinese? I know it's easy, but....
Hey! Congrats! Go Jeffrey! Go Lisp! Go Jeffrey! Go Lisp!
kt
> Would we have to learn Chinese? I know it's easy, but....
No, just Ruby and Javascript. (Which are, as it turns out, similar to
Chinese in the very way that you mention!)
From: Kenny
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <48687c3c$0$5012$607ed4bc@cv.net>
Jeff Shrager wrote:
>> Would we have to learn Chinese? I know it's easy, but....
>
> No, just Ruby and Javascript. (Which are, as it turns out, similar to
> Chinese in the very way that you mention!)
I love it when they ask for more than a week's experience in a language.
Of course at the ends of the curve we have C++ and Lisp and it /does/
make a difference, so asking these Qs in Lisp goups is bound to make
trouble")
> I love it when they ask for more than a week's experience in a language.
> Of course at the ends of the curve we have C++ and Lisp and it /does/
> make a difference, so asking these Qs in Lisp goups is bound to make
> trouble")
Not sure what you're saying, but our theory is that if you ask for
engineers in the language you're looking for, you get that and ONLY
that (at least this has been our experience so far). These days a big
project, and esp. one with any interesting knowledge content, requires
engineering in about 6 different paradigms ranging, as you say, from C
to Lisp (and beyond!, e.g., Theorem Proving) So we need engineers who
can program their way through anything ... and enjoy it! It's easy to
find folks who can program their way UP TO Lisp, but hard to find ones
that can program IN or BEYOND Lisp. It seems to be much easier to find
Lisp engineers who can program DOWN through C, etc. I don't know why
this is. Hypotheses range from "Lisp hackers are just smarter than
everyone else. (It's the abstraction, man...pass that joint!)" to
"Lisp hackers have had to learn to program down out of necessity of
paying the rent." to "Lisp hackers are just older and wiser, that is,
they have more experience." Whatever the reason, engineers who are
locked into one paradigm aren't even worth interviewing anylonger,
esp. when that paradigm isn't Lisp. (Another perfectly plausible
hypothesis is that I'm just biased!)
From: Kenny
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <486c8321$0$11598$607ed4bc@cv.net>
Jeff Shrager wrote:
>> I love it when they ask for more than a week's experience in a language.
>> Of course at the ends of the curve we have C++ and Lisp and it /does/
>> make a difference, so asking these Qs in Lisp goups is bound to make
>> trouble")
>
> Not sure what you're saying, but our theory is that if you ask for
> engineers in the language you're looking for, you get that and ONLY
> that (at least this has been our experience so far). These days a big
> project, and esp. one with any interesting knowledge content, requires
> engineering in about 6 different paradigms ranging, as you say, from C
> to Lisp (and beyond!, e.g., Theorem Proving) So we need engineers who
> can program their way through anything ... and enjoy it! It's easy to
> find folks who can program their way UP TO Lisp, but hard to find ones
> that can program IN or BEYOND Lisp. It seems to be much easier to find
> Lisp engineers who can program DOWN through C, etc. I don't know why
> this is. Hypotheses range from "Lisp hackers are just smarter than
> everyone else. (It's the abstraction, man...pass that joint!)" to
> "Lisp hackers have had to learn to program down out of necessity of
> paying the rent." to "Lisp hackers are just older and wiser, that is,
> they have more experience." Whatever the reason, engineers who are
> locked into one paradigm aren't even worth interviewing anylonger,
> esp. when that paradigm isn't Lisp. (Another perfectly plausible
> hypothesis is that I'm just biased!)
Or:
http://smuglispweeny.blogspot.com/2008/07/its-shoes-jeff-its-shoes.html
hth, kt
From: Alex Mizrahi
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <op.udpwthpaldr535@your-a80c79e8b3>
> Or:
>
> http://smuglispweeny.blogspot.com/2008/07/its-shoes-jeff-its-shoes.html
i completely disagree with your point.
personally, i don't think that i
learned a lot of fundamental stuff when learning lisp. closures and
first class functions were new to me, but i don't think they are
utterly important. CLOS and, particularly, method dispatch for sure
improved my understanding of OOP -- but again it's of limited use,
and i had pretty good OOP internals understanding before learning Lisp.
i think i aquired most of my programming skills when learning such
rare and complex languages as BASIC and Pascal. since then, learning
Object Pascal, C++, PHP, JS and even Lisp was not particularly hard --
i just checked what was the syntax for concepts i already knew,
common idioms and new features -- and wow, i know one more language.
(the only language i failed with is Perl -- despite i was using
it for various things from text processing to system hacking (as
it has wonderful libraries), i'm very far from being comfortable
with this damned language; i guess that's not my problem actually)
well, my experience might be atypical, let's go to a specific features
that you think make Lisp that good for training in language learning.
* syntatic freedom, openess, code is data? -- that's good,
but not as good as trying to write your own interpreter of some
(better your own) language.
writing an interpreter will give you a lot of experience in understanding
internal structure of programming language, and when you'll be learning
a new one, you can imagine how it was designed and implemented -- and that
gives very good understanding.
lisp might give insights about language's internal structure to those
who never tried making their own interpeter, but, i guess, many
(good?) programmers did so, or at least tried?
* multiple paradigms. come on, which ones?
functional? even JavaScripts supports them, i guess lisp is only
a bit more functional than JS, which almost any web developer knows.
declarative? even enterprisey Java programmers discovered
declarative programming in a form of tons of XML required to
launch application.
object oriented? again, most languages out there allow you
to write both object oriented and normal code.
* multiple way to do a thing. i don't think Lisp is a champion
here. probably you know about Perl?
ok, once i've defeated all of your arguments, we can go back to
original discussion. what makes lisp programmers better than others?
i guess it's just a statistical correlation attributed to multiple factors.
one that you've mentioned might be among them -- for sure Lisp
gives you more language-learning experience than C, Basic or Pascal.
other reasons might be that being quite unpopular language,
Lisp is often studied by those who are truly interested in
programming languages and is curious. learning language in
your free time out of curiosity will go fine only if
you're smart and good at learning languages, so we can see
corelation here too.
(it's like your "We are accustomed to learning other languages"
but reason is completely different -- i don't think many
people learn lisp as their first language nowadays).
also, Lisp is a bit more complex than some average
language out there, so probably those who failed
to master it are making their careers in Basic,
and those who remained are sort of smarter.
and, finally, older and wiser folks.. quite possible
older folks are just smarter because programming was much
less popular profession than it is now, and only those
who were smart enough came to it. and experience counts too..
thus, we have a community of old, wise experienced folks on
one side, and young, enthusiastic, curious on another. of
course such community would be smarter on average than your
average language community out there.
QED
From: Kenny
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <486ce44d$0$5010$607ed4bc@cv.net>
Alex Mizrahi wrote:
> ok, once i've defeated all of your arguments,...
Ah, but you used many of the reasonable ideas Jeff offered which I
rejected because they got in the way of my Nike Theory... nothing must
stand in the way of a Nike Theory!
:)
kenny
ps. Language note, that should be "now that I defeated...". If you were
planning a future demolition, you would say "Once I have defeated all
your arguments I will propose...". hthk
From: Pascal J. Bourguignon
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <7cvdzn8238.fsf@pbourguignon.anevia.com>
"Alex Mizrahi" <············@gmail.com> writes:
> ok, once i've defeated all of your arguments, we can go back to
> original discussion. what makes lisp programmers better than others?
> i guess it's just a statistical correlation attributed to multiple factors.
>
> one that you've mentioned might be among them -- for sure Lisp
> gives you more language-learning experience than C, Basic or Pascal.
>
> other reasons might be that being quite unpopular language,
> Lisp is often studied by those who are truly interested in
> programming languages and is curious. learning language in
> your free time out of curiosity will go fine only if
> you're smart and good at learning languages, so we can see
> corelation here too.
>
> (it's like your "We are accustomed to learning other languages"
> but reason is completely different -- i don't think many
> people learn lisp as their first language nowadays).
>
> also, Lisp is a bit more complex than some average
> language out there, so probably those who failed
> to master it are making their careers in Basic,
> and those who remained are sort of smarter.
>
> and, finally, older and wiser folks.. quite possible
> older folks are just smarter because programming was much
> less popular profession than it is now, and only those
> who were smart enough came to it. and experience counts too..
>
> thus, we have a community of old, wise experienced folks on
> one side, and young, enthusiastic, curious on another. of
> course such community would be smarter on average than your
> average language community out there.
If that was all there is to it, then why Fortran programmers are not smarter?
(well actually they might be smarter, but not in CS, in Physics rather :-))
--
__Pascal Bourguignon__
From: Alex Mizrahi
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <op.udp15hxmldr535@your-a80c79e8b3>
> If that was all there is to it, then why Fortran programmers are not
> smarter?
yep, i was thinking about that, but not about Fortran guys but those
who coded directly in machine language (not even via assembly!).
my numeric methods teacher was one of them -- he telled stories
about time when machines were big. once they recieved such machine
and found out that it's not equipped with no software, not even
libraries to do math functions like cosine. so they had to write
these functions directly in machine language -- using just
documentation and probably having very little experience,
coding those functions via Taylor series etc.
and they got it working. in addition, machine was buggy as hell --
perfectly correct code could fail producing wrong results.
i guess debugging was quite a challenge..
so i thought guys who did it were very smart. but it seems his
interests were only numeric methods and some physical modelling,
as he did not even bother learning C.. (unlike his friend,
who even published a book, that could be called
"doing FORTRAN stuff in C++"). so his students could
show him totally incorrect program as long as returned correct results
(he was checking results calculating stuff using pen and
sheet of paper).
> (well actually they might be smarter, but not in CS, in Physics rather
> :-))
yep, if one concentrates in his problem domain he won't get general
programming experience. but if we'll count only active community members,
they are quite likely to be interested in CS and to accumulate wealth
of experience with years
Alex Mizrahi <············@gmail.com> wrote:
> > If that was all there is to it, then why Fortran programmers are not
> > smarter?
>
> yep, i was thinking about that, but not about Fortran guys but those
> who coded directly in machine language (not even via assembly!).
>
> my numeric methods teacher was one of them ...
Maybe the difference is that Fortran (et. al.) programmers are more
interested in the result, while Lisp programmers are more interested in
the language. YMMV.
From: Tim X
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <871w2amdgq.fsf@lion.rapttech.com.au>
"Alex Mizrahi" <············@gmail.com> writes:
>> Or:
>>
>> http://smuglispweeny.blogspot.com/2008/07/its-shoes-jeff-its-shoes.html
>
> i completely disagree with your point.
>
> personally, i don't think that i
> learned a lot of fundamental stuff when learning lisp. closures and
> first class functions were new to me, but i don't think they are
> utterly important. CLOS and, particularly, method dispatch for sure
> improved my understanding of OOP -- but again it's of limited use,
> and i had pretty good OOP internals understanding before learning Lisp.
>
> i think i aquired most of my programming skills when learning such
> rare and complex languages as BASIC and Pascal. since then, learning
> Object Pascal, C++, PHP, JS and even Lisp was not particularly hard --
> i just checked what was the syntax for concepts i already knew,
> common idioms and new features -- and wow, i know one more language.
> (the only language i failed with is Perl -- despite i was using
> it for various things from text processing to system hacking (as
> it has wonderful libraries), i'm very far from being comfortable
> with this damned language; i guess that's not my problem actually)
>
> well, my experience might be atypical, let's go to a specific features
> that you think make Lisp that good for training in language learning.
>
> * syntatic freedom, openess, code is data? -- that's good,
> but not as good as trying to write your own interpreter of some
> (better your own) language.
>
> writing an interpreter will give you a lot of experience in understanding
> internal structure of programming language, and when you'll be learning
> a new one, you can imagine how it was designed and implemented -- and that
> gives very good understanding.
>
> lisp might give insights about language's internal structure to those
> who never tried making their own interpeter, but, i guess, many
> (good?) programmers did so, or at least tried?
>
> * multiple paradigms. come on, which ones?
> functional? even JavaScripts supports them, i guess lisp is only
> a bit more functional than JS, which almost any web developer knows.
>
> declarative? even enterprisey Java programmers discovered
> declarative programming in a form of tons of XML required to
> launch application.
>
> object oriented? again, most languages out there allow you
> to write both object oriented and normal code.
>
> * multiple way to do a thing. i don't think Lisp is a champion
> here. probably you know about Perl?
>
> ok, once i've defeated all of your arguments, we can go back to
> original discussion. what makes lisp programmers better than others?
> i guess it's just a statistical correlation attributed to multiple factors.
>
> one that you've mentioned might be among them -- for sure Lisp
> gives you more language-learning experience than C, Basic or Pascal.
>
> other reasons might be that being quite unpopular language,
> Lisp is often studied by those who are truly interested in
> programming languages and is curious. learning language in
> your free time out of curiosity will go fine only if
> you're smart and good at learning languages, so we can see
> corelation here too.
>
> (it's like your "We are accustomed to learning other languages"
> but reason is completely different -- i don't think many
> people learn lisp as their first language nowadays).
>
> also, Lisp is a bit more complex than some average
> language out there, so probably those who failed
> to master it are making their careers in Basic,
> and those who remained are sort of smarter.
>
> and, finally, older and wiser folks.. quite possible
> older folks are just smarter because programming was much
> less popular profession than it is now, and only those
> who were smart enough came to it. and experience counts too..
>
> thus, we have a community of old, wise experienced folks on
> one side, and young, enthusiastic, curious on another. of
> course such community would be smarter on average than your
> average language community out there.
>
> QED
>
The problem I have with these arguments is what seems to be a general
belief that lisp programmers are smarter/better. Where is the evidence
for this? I've seen no research that tries to determine this assumption
and I'm not even sure you could.
There have certainly been some lisp programmers that do seem very good,
but I suspect they would have been good using any language. There are
also some programmers that appear to be very good who don't use lisp.
My suspicion is that in reality, lisp programmers are no better than
good programmers in any language and the language is largely
irrelevant. The 'truth' of lisp making you a better programmer is more
likely something that has developed as a largely unconscious defence
against all the (largely misinformed) criticisms of the language. The
observation that there seems to be a higher proportion of 'good'
programmers using lisp is likely just due to the fact it isn't a popular
language and those who do decide to stick with it probably have a higher
interest in the art and therefore seem better. A genuine
interest or sometimes even passion for programming and its underlying
concepts will generally produce a better programmer than someone who
just does it as a 9-5 job - the language is largely irrelevant. I do
find lisp makes it easier than many languages to 'experiment' and learn,
but its the interest in doing that which makes a better programmer. The
language just facilitates the process. Other languages can also
facilitate the process - for example, I've used perl, ruby and TCL in a
similar way.
I personally find the idea of lisp making you a better programmer coming
out of lisp forums and from lisp programmers rather arrogant and more
often than not a sign that lisp programmers may actually have a higher
proportion of insecure programmers than good ones.
I like lisp because of its consistency and simplicity
compared to other languages and because it fits well with the way I like
to think about and solve problems. It has probably made me a better
programmer because it has allowed me to experiment with concepts and
therefore facilitated my learning and level of understanding, but that
is mainly due to my interest in the topic and not lisp. In fact, I think
many of the attributes that make a good programmer are language neutral
- the ability to aquire enough information about the problem domain and
abstract it in such a way to make the algorithms straight-forward and
possibly even elegant, the ability to ask the right questions to get the
right information, the ability to get inside the head of the end user,
the ability to consider on-going maintenance and development aspects,
the ability to learn and understand the subtleties of a problem domain
that may be very different to anything you have encountered before and
good communicaiton skils are all essential qualities for a good
programmer.
Tim
--
tcross (at) rapttech dot com dot au
On Jul 3, 10:21 pm, Tim X <····@nospam.dev.null> wrote:
>
> The 'truth' of lisp making you a better programmer is more
> likely something that has developed as a largely unconscious defence
> against all the (largely misinformed) criticisms of the language.
Alex has replied to you very well, but I just want to add one thing.
I do believe that learning a language with good support for the
functional style will make one a better programmer. It doesn't have
to be Lisp (or Scheme); there are many good semi-functional(*)
languages around these days -- such as the ML family and Scala -- and
of course there's also the fully functional Haskell.
It's not that Lisp is magic, it's that the functional style is an
important tool to have in one's toolbox.
BTW I would also encourage everyone to learn Prolog. We don't talk
about it much in this NG, but it's also a mind-expanding experience.
And for further enlightenment in that direction, check out constraint
logic programming on the one hand, and Mercury on the other.
-- Scott
(*) "Semi-functional" is my term for languages that support functional
programming well but also have imperative constructs.
From: Vassil Nikolov
Subject: enlightenment in computer programming (Ex: CollabRx seeks brilliant engineers for an excellent e-science adventure)
Date:
Message-ID: <snzy74hmnqv.fsf_-_@luna.vassil.nikolov.name>
On Fri, 4 Jul 2008 11:32:39 -0700 (PDT), Scott Burson <········@gmail.com> said:
| ...
| I do believe that learning a language with good support for the
| functional style will make one a better programmer. It doesn't have
| to be Lisp (or Scheme); there are many good semi-functional
| languages around these days -- such as the ML family and Scala -- and
| of course there's also the fully functional Haskell.
| ...
| BTW I would also encourage everyone to learn Prolog. We don't talk
| about it much in this NG, but it's also a mind-expanding experience.
| And for further enlightenment in that direction, check out constraint
| logic programming on the one hand, and Mercury on the other.
Furthermore, good, modern enlightenment in this subject area in
general can be found in this book:
Peter Van Roy and Seif Haridi
_Concepts, Techniques, and Models of Computer Programming_
The MIT Press
Cambridge, Massachusetts
London, England
2004
ISBN 0-262-22069-5
xxx+900 pages
Summary of contents:
1 Introduction to Programming Concepts
I GENERAL COMPUTATION MODELS
2 Declarative Computation Model
3 Declarative Programming Techniques
4 Declarative Concurrency
5 Message-Passing Concurrency
6 Explicit State
7 Object-Oriented Programming
8 Shared-State Concurrency
9 Relational Programming
II SPECIALIZED COMPUTATION MODELS
10 Graphical User Interface Programming
11 Distributed Programming
12 Constraint Programming
III SEMANTICS
13 Language Semantics
IV APPENDIXES
A Mozart System Development Environment
B Basic Data Types
C Language Syntax
D General Computation Model
Back cover endorsements by Brian Harvey and Peter Norvig.
---Vassil.
--
Peius melius est. ---Ricardus Gabriel.
From: Sohail Somani
Subject: Re: enlightenment in computer programming (Ex: CollabRx seeks brilliant engineers for an excellent e-science adventure)
Date:
Message-ID: <Suvbk.1997$7%6.1786@edtnps82>
Vassil Nikolov wrote:
> On Fri, 4 Jul 2008 11:32:39 -0700 (PDT), Scott Burson <········@gmail.com> said:
> | ...
> | I do believe that learning a language with good support for the
> | functional style will make one a better programmer. It doesn't have
> | to be Lisp (or Scheme); there are many good semi-functional
> | languages around these days -- such as the ML family and Scala -- and
> | of course there's also the fully functional Haskell.
> | ...
> | BTW I would also encourage everyone to learn Prolog. We don't talk
> | about it much in this NG, but it's also a mind-expanding experience.
> | And for further enlightenment in that direction, check out constraint
> | logic programming on the one hand, and Mercury on the other.
>
> Furthermore, good, modern enlightenment in this subject area in
> general can be found in this book:
I presume at some point people in this NG will actually write some code.
On Jul 4, 7:21 am, Tim X <····@nospam.dev.null> wrote:
> "Alex Mizrahi" <············@gmail.com> writes:
> >> Or:
>
> >>http://smuglispweeny.blogspot.com/2008/07/its-shoes-jeff-its-shoes.html
>
> > i completely disagree with your point.
>
> > personally, i don't think that i
> > learned a lot of fundamental stuff when learning lisp. closures and
> > first class functions were new to me, but i don't think they are
> > utterly important. CLOS and, particularly, method dispatch for sure
> > improved my understanding of OOP -- but again it's of limited use,
> > and i had pretty good OOP internals understanding before learning Lisp.
>
> > i think i aquired most of my programming skills when learning such
> > rare and complex languages as BASIC and Pascal. since then, learning
> > Object Pascal, C++, PHP, JS and even Lisp was not particularly hard --
> > i just checked what was the syntax for concepts i already knew,
> > common idioms and new features -- and wow, i know one more language.
> > (the only language i failed with is Perl -- despite i was using
> > it for various things from text processing to system hacking (as
> > it has wonderful libraries), i'm very far from being comfortable
> > with this damned language; i guess that's not my problem actually)
>
> > well, my experience might be atypical, let's go to a specific features
> > that you think make Lisp that good for training in language learning.
>
> > * syntatic freedom, openess, code is data? -- that's good,
> > but not as good as trying to write your own interpreter of some
> > (better your own) language.
>
> > writing an interpreter will give you a lot of experience in understanding
> > internal structure of programming language, and when you'll be learning
> > a new one, you can imagine how it was designed and implemented -- and that
> > gives very good understanding.
>
> > lisp might give insights about language's internal structure to those
> > who never tried making their own interpeter, but, i guess, many
> > (good?) programmers did so, or at least tried?
>
> > * multiple paradigms. come on, which ones?
> > functional? even JavaScripts supports them, i guess lisp is only
> > a bit more functional than JS, which almost any web developer knows.
>
> > declarative? even enterprisey Java programmers discovered
> > declarative programming in a form of tons of XML required to
> > launch application.
>
> > object oriented? again, most languages out there allow you
> > to write both object oriented and normal code.
>
> > * multiple way to do a thing. i don't think Lisp is a champion
> > here. probably you know about Perl?
>
> > ok, once i've defeated all of your arguments, we can go back to
> > original discussion. what makes lisp programmers better than others?
> > i guess it's just a statistical correlation attributed to multiple factors.
>
> > one that you've mentioned might be among them -- for sure Lisp
> > gives you more language-learning experience than C, Basic or Pascal.
>
> > other reasons might be that being quite unpopular language,
> > Lisp is often studied by those who are truly interested in
> > programming languages and is curious. learning language in
> > your free time out of curiosity will go fine only if
> > you're smart and good at learning languages, so we can see
> > corelation here too.
>
> > (it's like your "We are accustomed to learning other languages"
> > but reason is completely different -- i don't think many
> > people learn lisp as their first language nowadays).
>
> > also, Lisp is a bit more complex than some average
> > language out there, so probably those who failed
> > to master it are making their careers in Basic,
> > and those who remained are sort of smarter.
>
> > and, finally, older and wiser folks.. quite possible
> > older folks are just smarter because programming was much
> > less popular profession than it is now, and only those
> > who were smart enough came to it. and experience counts too..
>
> > thus, we have a community of old, wise experienced folks on
> > one side, and young, enthusiastic, curious on another. of
> > course such community would be smarter on average than your
> > average language community out there.
>
> > QED
>
> The problem I have with these arguments is what seems to be a general
> belief that lisp programmers are smarter/better. Where is the evidence
> for this? I've seen no research that tries to determine this assumption
> and I'm not even sure you could.
>
> There have certainly been some lisp programmers that do seem very good,
> but I suspect they would have been good using any language. There are
> also some programmers that appear to be very good who don't use lisp.
>
> My suspicion is that in reality, lisp programmers are no better than
> good programmers in any language and the language is largely
> irrelevant. The 'truth' of lisp making you a better programmer is more
> likely something that has developed as a largely unconscious defence
> against all the (largely misinformed) criticisms of the language. The
> observation that there seems to be a higher proportion of 'good'
> programmers using lisp is likely just due to the fact it isn't a popular
> language and those who do decide to stick with it probably have a higher
> interest in the art and therefore seem better. A genuine
> interest or sometimes even passion for programming and its underlying
> concepts will generally produce a better programmer than someone who
> just does it as a 9-5 job - the language is largely irrelevant. I do
> find lisp makes it easier than many languages to 'experiment' and learn,
> but its the interest in doing that which makes a better programmer. The
> language just facilitates the process. Other languages can also
> facilitate the process - for example, I've used perl, ruby and TCL in a
> similar way.
>
> I personally find the idea of lisp making you a better programmer coming
> out of lisp forums and from lisp programmers rather arrogant and more
> often than not a sign that lisp programmers may actually have a higher
> proportion of insecure programmers than good ones.
>
> I like lisp because of its consistency and simplicity
> compared to other languages and because it fits well with the way I like
> to think about and solve problems. It has probably made me a better
> programmer because it has allowed me to experiment with concepts and
> therefore facilitated my learning and level of understanding, but that
> is mainly due to my interest in the topic and not lisp. In fact, I think
> many of the attributes that make a good programmer are language neutral
> - the ability to aquire enough information about the problem domain and
> abstract it in such a way to make the algorithms straight-forward and
> possibly even elegant, the ability to ask the right questions to get the
> right information, the ability to get inside the head of the end user,
> the ability to consider on-going maintenance and development aspects,
> the ability to learn and understand the subtleties of a problem domain
> that may be very different to anything you have encountered before and
> good communicaiton skils are all essential qualities for a good
> programmer.
>
> Tim
>
> --
> tcross (at) rapttech dot com dot au
Knowing classical music does not magically turn you into a better
musician; still, I think most great musicians know at least some
classical music.
This is a silly example, but what I want to say is that of course Lisp
does not make you a better programmer: you can be a bad programmer in
any language you want. IMHO the process is the opposite: good
programmers tend to not be satisfied by "mainstream" languages and to
look for more, and some of them end up liking Lisp.
Of course there's nothing Lisp-specific about this; Haskell or Prolog
programmers, for example, are probably as smart as Lisp programmers.
We all know Lisp has tons of great features which make it an excellent
language, but the same is true for other languages as well. To be
profitable, a language has to be suitable for the programmer's way of
thinking. The difference is that good programmers choose the language
that fits them best, average programmers just accept whatever language
is mainstream.
Cheers
Alessio
From: Alex Mizrahi
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <op.udscc9a6ldr535@your-a80c79e8b3>
> thinking. The difference is that good programmers choose the language
> that fits them best, average programmers just accept whatever language
> is mainstream.
perhaps "average" programmers also pick what fits them best.
best example is PHP -- it was created by a hobbist guy
for his personal home page, and other amateur web designers
picked that langauge; despite it was made extremely unprofessionaly,
it fitted them very well, being very simple, but including
features they want.
BASIC is another example -- i'm pretty sure some people appreciate
it for simplicity etc.
From: Alex Mizrahi
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <op.udrhdl1gldr535@your-a80c79e8b3>
> The problem I have with these arguments is what seems to be a general
> belief that lisp programmers are smarter/better.
that's what Jeff says -- his experience is that people who
know Lisp are more suitable for position he has.
> Where is the evidence for this?
i'm afraid nothing but personal subjective experience.
note that nobody says all lispers are smart -- just
there is higher percent of smart people than, say, among
Java or PHP programmers.
> I've seen no research that tries to determine this assumption
> and I'm not even sure you could.
i remember research by Erann Gat, it not exactly shows
that lispers are smarter, but at least something..
> There have certainly been some lisp programmers that do seem very good,
> but I suspect they would have been good using any language.
this is exactly what Jeff wants -- people who will be good with any
language. how do you find such people? "we want programmers in
everything"?
> There are
> also some programmers that appear to be very good who don't use lisp.
sure, but i bet almsot any really good programmer knows at least
one of advanced languages like Lisp, Haskell or ML. (Python in worst case).
i doubt you can find extremely smart programmer who was not curious
to learn anything but Java.
> My suspicion is that in reality, lisp programmers are no better than
> good programmers in any language and the language is largely
> irrelevant.
so you simply deny _obvious_ correlations i've mentioned?
i suggest you reading this essay by Paul Graham, it's
about Python but not Lisp, by the way, maybe you'll
understand it better from second time:
http://paulgraham.com/pypar.html
> The 'truth' of lisp making you a better programmer is more
> likely something that has developed as a largely unconscious defence
> against all the (largely misinformed) criticisms of the language.
you say it like we people at lisp community are devoted fanatics,
or something, and need to defend our cult language at all costs.
i can't say for everyone, but i'm definitely not a fanatic;
besides Lisp i know something like a dozed other languages --
C++, Python, PHP, Java, etc -- and from time to time i have
to program in some of them. while i like Lisp more than
other languages, i know that it's not perfect, and can say
in which aspects other languages are better. (for me,
benefits outweight costs, that's why i like lisp more).
also, i've seen programming communities on other languages --
C++, PHP, Java, Delphi -- and i never seen people as smart and
friendly as in comp.lang.lisp. barely in other community
you'll see newbie question being answered by language
experts, with thorough explanations and examples. (often
you can see answers like "you read FAQ, bitch!"). barely
you can find people discussing such wide variety of topics,
in other groups you can find people shouting "offtopic!
go out of here, bastard" (even if question was ontopic,
after closer examinations).
another interesting detail is that i haven't seen
amount of introspection present in comp.lang.lisp in other
communities. you can find here weird topics of all sorts --
about social problems of lisp, about personality of lisp
programmers, about lisp programmers being special (smart etc),
and finally you came with deeply psychological idea that
under criticism lisp community have formed a defensive
delusion that lisp programmers are better.. i'm not sure
what is the reason for such introspection, maybe it's
also some defensive mechanism? well, i'm not crazy enough
to continue topic about meta-instrospection..
> The
> observation that there seems to be a higher proportion of 'good'
> programmers using lisp
you contradict yourself -- you said that Lisp is not anyhow better
than _any_ other language above..
is likely just due to the fact it isn't a popular
> language and those who do decide to stick with it probably have a higher
> interest in the art and therefore seem better.
yep, this is one of correlations, but don't you think that
choice of people who are 'good' programmers and have a higher interest
in the art is not entirely random? or they are just picking
any unpopluar language and form a community around it?
> A genuine
> interest or sometimes even passion for programming and its underlying
> concepts will generally produce a better programmer than someone who
> just does it as a 9-5 job - the language is largely irrelevant.
unless some unfortunate luck, genuine interest and passion will
drive programmer to a language which is better suited for his needs.
please don't tell us stories -- it would be very hard to satisfy
passion in programming in some dumb Visual Basic or PHP.
> I do
> find lisp makes it easier than many languages to 'experiment' and learn,
> but its the interest in doing that which makes a better programmer.
yep, that's exactly what i was saying. i'll remind that Kenny
wrote an essay that Lisp makes you a better programmer, i've wrote
a reply that this factor should be less significant than
a statistical correlation between knowing Lisp and being smart.
either you have problems understanding large pieces of text,
or you're replying to a wrong message -- you should argue with
Kenny instead.
> I like lisp because of its consistency and simplicity
> compared to other languages and because it fits well with the way I like
> to think about and solve problems. It has probably made me a better
> programmer because it has allowed me to experiment with concepts and
> therefore facilitated my learning and level of understanding, but that
> is mainly due to my interest in the topic and not lisp.
can you decide -- did lisp help you or not? could you achieve same
improvement programming in VB or PHP? i guess no? then language
matters, a little at least?
why didn't you stay with Ruby, Perl or Tcl? probably you have
found something limiting about them? probably you have found
some inconsistencies and unneeded complexity, inelegance?
you see, probably you was able to spot issues where other
people see none. maybe that says something about you.
maybe you have some better programming language sense,
better understanding about it's internal logic and structure.
and this aptitude made you learning lisp..
that what makes me think that some average lisper might be
a bit smarter than average rubist -- rubist was not able
to spot some weirdness of the language, it didn't bother
him, he did not care about elegance -- so he might be
a bit worse in programming languages.
> In fact, I think
> many of the attributes that make a good programmer are language neutral
> - the ability to aquire enough information about the problem domain and
> abstract it in such a way to make the algorithms straight-forward and
> possibly even elegant, the ability to ask the right questions to get the
> right information, the ability to get inside the head of the end user,
> the ability to consider on-going maintenance and development aspects,
> the ability to learn and understand the subtleties of a problem domain
> that may be very different to anything you have encountered before and
> good communicaiton skils are all essential qualities for a good
> programmer.
yep, this is right, it is what i said to Kenny -- there is no magic
stuff in Lisp that teaches you everything about programming.
p.s. i had no intention to abuse Ruby, Python, Tcl etc users --
this is just my subjective feeling that these languages are inferior
to Lisp. i do not place Lisp at top of the list thought -- i think
Haskell, for example, requires even more intellect than Lisp does,
so i do not even dare learning it..
From: Frank "frgo" a.k.a DG1SBG
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <lz1w29z9sl.fsf@goenninger.net>
"Alex Mizrahi" <············@gmail.com> writes:
>> The problem I have with these arguments is what seems to be a general
>> belief that lisp programmers are smarter/better.
>
> that's what Jeff says -- his experience is that people who
> know Lisp are more suitable for position he has.
>
>> Where is the evidence for this?
>
> i'm afraid nothing but personal subjective experience.
> note that nobody says all lispers are smart -- just
> there is higher percent of smart people than, say, among
> Java or PHP programmers.
Oh come on. This is so obvious but it seems it has to be said so that
everyone can chew on it:
Any programmer's value is determined by experience. Why? Because she
has made so many errors and learned to debug and thereby learnt to
recognize erros and so learnt to avoid errors and so got more
productive and so ...
Lisp? Harder to learn. Why? Don't know. Just my own experience. And I
don't care. If I did care then an ABAP programmer would be even more
valuable because ABAP definitely is even harder to learn. No, not
science, but my own experience, too.
And there is was again, that all defining set of words: "My own
experience". It's the two who makes a fit: The one looking for a
programmer and the one being the programmer who applies for a
job. Only a part of that equation is on the programmer's side and only
a part of that is her Lisp skills.
Ever had a good looking gal sitting at the other side of the table? Oh
boy, there are hiring managers which gave her a top grade without any
keyboard being touched...
;-)
Frank
--
Frank Goenninger
frgo(at)mac(dot)com
"Don't ask me! I haven't been reading comp.lang.lisp long enough to
really know ..."
From: Sohail Somani
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <kSvbk.2003$7%6.371@edtnps82>
Frank "frgo" a.k.a DG1SBG wrote:
> Lisp? Harder to learn. Why? Don't know. Just my own experience. And I
> don't care. If I did care then an ABAP programmer would be even more
> valuable because ABAP definitely is even harder to learn. No, not
> science, but my own experience, too.
To me, what makes a language harder to learn is how many restrictions it
has. Common Lisp doesn't seem to have many restrictions that get in my
way so it has been very damn easy.
I have recently gotten familiar with the mini-language in format. I used
to think C++ iostreams were feeble compared to the all-awesome printf.
But wow, compared to format, everything sucks.
From: Tim X
Subject: Re: CollabRx seeks brilliant engineers for an excellent e-science adventure
Date:
Message-ID: <87iqvksh54.fsf@lion.rapttech.com.au>
"Alex Mizrahi" <············@gmail.com> writes:
>> The problem I have with these arguments is what seems to be a general
>> belief that lisp programmers are smarter/better.
>
> that's what Jeff says -- his experience is that people who
> know Lisp are more suitable for position he has.
>
>> Where is the evidence for this?
>
> i'm afraid nothing but personal subjective experience.
> note that nobody says all lispers are smart -- just
> there is higher percent of smart people than, say, among
> Java or PHP programmers.
>
That is the type of statement I am skeptical about. I know a lot of very smart
programmers that work in Java. I also know a lot of Java programmers I
don't think are very good - but I know a hell of a lot more java
programmers than I do lisp programmers. Most of the lisp programmers
that I actually know do seem pretty smart, but is that a function of the
type of programmer I associate with, a skewed representation, the
language, whishful thinking or some other aspect of my personality that
makes me perceive it that way or even something as simple as lisp being
a type of language that attracts a personality that meets my perceptions
of what is a good programmer?
>> I've seen no research that tries to determine this assumption
>> and I'm not even sure you could.
>
> i remember research by Erann Gat, it not exactly shows
> that lispers are smarter, but at least something..
>
>> There have certainly been some lisp programmers that do seem very good,
>> but I suspect they would have been good using any language.
>
> this is exactly what Jeff wants -- people who will be good with any
> language. how do you find such people? "we want programmers in
> everything"?
>
I'm not arguing against Jeff's point and agree that you would likely
find more programmers that use lisp that are also able to adapt to other
languages and paradigms. My point is that I don't believe lisp is
necessarily the dependent variable in the equation. It may not be lisp
that made them so, merely that those who are of this type also
happen,more often than not, to also know lisp.
>> There are
>> also some programmers that appear to be very good who don't use lisp.
>
> sure, but i bet almsot any really good programmer knows at least
> one of advanced languages like Lisp, Haskell or ML. (Python in worst case).
> i doubt you can find extremely smart programmer who was not curious
> to learn anything but Java.
>
Actually, I know a lot of very good programmers who know next to nothing
of any of those languages, especially programmers who didn't learn their
skills in the US. For example, in Australia, lisp was not used much in
any of the Universities. You werer more likely to find Prolog than lisp
(including scheme). These days, your unlikely to find either and you
would be lucky to cover it in any more depth than one or two weeks in a
course on something like non-procedural languages.
I've known and worked with some really talented programmers who have
only known one style of language i.e. often C, C++ and Java and thats it.
>> My suspicion is that in reality, lisp programmers are no better than
>> good programmers in any language and the language is largely
>> irrelevant.
>
> so you simply deny _obvious_ correlations i've mentioned?
>
I deny they are as obvious as you imply, I question they actually
represent a correlation based on knowing and programming in lisp. As you
pointed out, it is a subjective proposition without any empirical
evidence. to be "obvious" to everyone, we would all need the same
subjective experiences. My observations and experience make me question
whether lisp is actually the determining factor in what makes a good
programmer. As Jeff stated, his opinion may be biased because of his
associations with lisp. If he had been a C programmer, he may have
argued that it is only C programmers in his experience that are able to
adjust to the different paradigms.
My opinion may be biased by the fact I came to lisp quite late in my
career and had learnt many other languages and got to know many smart
programmers in all of those languages.
> i suggest you reading this essay by Paul Graham, it's
> about Python but not Lisp, by the way, maybe you'll
> understand it better from second time:
>
> http://paulgraham.com/pypar.html
>
Understand it better! Just because I don't necessarily agree doesn't
mean I don't understand it. Remember, its a subjective opinion on both
sides. Until someone is able to quantify things, its just theory and
while we can disagree on theory, neither can be said to be right or
wrong.
Note also that I'm not disagreeing with Jeff's opinion that he finds
programmers that know lisp suit the type of work he needs done and I
don't even disagree with the premise that you find a lot of lisp
programmers are good. What I am skeptical about is that it is
programming in lisp itself that makes you a good programmer or that you
couldn't find a simlar group of good programmers based around a
different language, particularly a 'fringe' language.
I have read a lot of PG's essays. Some I like, many I find quite
humorous and some points I totally disagree with. Again, his are just
more subjective opinions on lots of things. He isn't some great
programming god. In fact, I think he is a smart man who was in the right
place at the right time and probably had the right tool. I also suspect
he could have done as well with a different tool (despite his argument
that it was lisp that made it all possible - I think it was more likely
down to the timing, the team of people and some good old fashioned
luck. There have been far more instances of smart people using lisp that
have failed to be as successful and even a lot of even smarter people
using other tools who have completely failed. In fact, I think that
quite often really smart people fail because they are just too far in
front and peak too early).
>> The 'truth' of lisp making you a better programmer is more
>> likely something that has developed as a largely unconscious defence
>> against all the (largely misinformed) criticisms of the language.
>
> you say it like we people at lisp community are devoted fanatics,
> or something, and need to defend our cult language at all costs.
>
Well, you certainly seem to be getting awfully defensive about it! Why
the 'us and them' stance? I program in lisp, I participate in
discussions and yet your statement implies I'm not part of the
'we'. Your point about reading PGs essays and then maybe I will
"understand" gives the impression that any opinion that at all differs
from the known truth that lisp is the best thing since sliced bread
could only be due to ignorance and reminds me of christian missionaries
trying to save the ignorant savage. All I have to do is read the PG
bible and I will see the light! This smells awfuly close to religious
dogma to me.
I do think there are many in the lisp community who are frustrated by
the lack of lisp acceptance in the wider programming world and the
levelof FUD associated with the language and yes, I think there is a
small part of the lisp community that does give the impression of being
fanatics and will defend the language at all costs. However, I think you
get that in almost all language communities and I don't think it is the
whole community or even a large subset of the community. I also fully
understand the stance of some in that subset. I too get frustrated by
some of the opinions/responses I get when trying to explain som eof the
unique aspects of the language and the high level of misunderstanding I
see - som eof which often comes from people who in all other ways seem
to be smart and talented programmers.
As an example, I was totally blown away with lisp's error handling and
conditional restarts etc. This was exactly what I'd been looking for and
and close to what I always thought a language should be able to
do. However, I've been totally frustrated in my attempts to explain it
to colleagues - as soon as I mention lisp, their eyes glaze over and
they just stop listening.
My comment was never meant to imply fanaticism or anything
else. However, from a sociological and psychological perspective, I tend
to think it is not outside the bounds of possibility that members of the
lisp community may develop a belief they represent a group of
programmers that are on the whole better than the average as a
subconscious defence mechanism. This is similar to the research done in
the late 70s that compared opinions of well paid and poorly paid workers
in various fields. The research found that those working for less pay
more often than not played up the importance of the job they did
compared to those who were paid at a higher rate. The researchers
concluded that this was due to subconscious rationalisation that helped
to justify their lower pay. I can't cite the actual research - it was
some of the stuff I covered as part of my second career (programming is
my third 'career') and was nearly 30 years ago. My point is that it is
possible a similar process is taking place here. In order to rationalise
why we are continuing to use a language that is unpopular, has few job
vacancies and can actually work against you in some situations (some
employers see lisp programmers as uber geeks that will be difficult to
manage, will continually challenge their decisions and authority and are
likley to get bored with the job in 3 montsh - often they are correct!)
we rationalise our choice by convincing ourselves we continue to
do it because it is the worlds best language and will make us better
programmers.
> i can't say for everyone, but i'm definitely not a fanatic;
> besides Lisp i know something like a dozed other languages --
> C++, Python, PHP, Java, etc -- and from time to time i have
> to program in some of them. while i like Lisp more than
> other languages, i know that it's not perfect, and can say
> in which aspects other languages are better. (for me,
> benefits outweight costs, that's why i like lisp more).
>
> also, i've seen programming communities on other languages --
> C++, PHP, Java, Delphi -- and i never seen people as smart and
> friendly as in comp.lang.lisp. barely in other community
> you'll see newbie question being answered by language
> experts, with thorough explanations and examples. (often
> you can see answers like "you read FAQ, bitch!"). barely
> you can find people discussing such wide variety of topics,
> in other groups you can find people shouting "offtopic!
> go out of here, bastard" (even if question was ontopic,
> after closer examinations).
>
Personally, I've seen nothing better or worse in the lisp communities
than most other language communities. All of them seem pretty much the same to
me. Some of the more domain specific popular languages do appear to have
a higher number of participants that don't appear to have a good grasp
of basic concepts that are generally accepted as being almost general
knowledge in other groups - for example, I've seen some questions in PHP
groups and PL/SQL groups that make it obvious the poster does not have a
strong programming background and is not familiar with concepts such as
recursion, pass by value, pass by reference, closures etc. However, this
doesn't mean they are stupid, smart or even bad programmers - it just
means they have come from a different direction and probably have a lot
of learning in front of them.
> another interesting detail is that i haven't seen
> amount of introspection present in comp.lang.lisp in other
> communities. you can find here weird topics of all sorts --
> about social problems of lisp, about personality of lisp
> programmers, about lisp programmers being special (smart etc),
> and finally you came with deeply psychological idea that
> under criticism lisp community have formed a defensive
> delusion that lisp programmers are better.. i'm not sure
> what is the reason for such introspection, maybe it's
> also some defensive mechanism? well, i'm not crazy enough
> to continue topic about meta-instrospection..
>
Well thats fine. I have to admit finding that paragraph a bit
confusing. You start by saying that you haven't seen the same level of
introspection in other groups as you find in c.l.l., but then you seem
to imply its odd that I raise such a thing (and in a thread that was
largely based on intraspection!)
I don't believe my post and observation was anything particularly
defensive and it certainly wasn't meant to make anyone feel anything
related to defensiveness or attack. I merely raised another possible
explination for why there is a perception that lisp programmers on
average are better or that lisp somehow creates/makes you a better
programmer. I was hoping, if nothing else, that maybe the points I
raised would make readers consider an alternative explination for the
perceived higher frequency of good programmers using lisp than other
languages - a perception which I have some reservationns about.
>> The
>> observation that there seems to be a higher proportion of 'good'
>> programmers using lisp
>
> you contradict yourself -- you said that Lisp is not anyhow better
> than _any_ other language above..
>
I don't believe I've contradicted myself at all. My point, right from
the start, was to quesiton the assumption the lisp makes you a better
programmer. I actually made no comment on the value of lisp as a
language and even explicitly stated that I like it as a language. My
only point was that I'm somewhat skeptical regarding whether lisp makes
you a better programmer to any greater extent than any other language
and whether in fact ther eis a higher proportion of good programmers
using lisp than there is for other languages.
> is likely just due to the fact it isn't a popular
>> language and those who do decide to stick with it probably have a higher
>> interest in the art and therefore seem better.
>
> yep, this is one of correlations, but don't you think that
> choice of people who are 'good' programmers and have a higher interest
> in the art is not entirely random? or they are just picking
> any unpopluar language and form a community around it?
>
I don't think its random. However, as you put it 'choice of people who
are 'good' programmers' indicates they were good programmers prior to
using lisp. My question and skepticism surrounds the assumption that
using lisp will make you a better programmer more than using any other
language. I think it is the interest in programming that brings many
people to lisp and as a result of that interest, they tend to be better
programmers. Learning lisp is likely to improve their skills, but so
will learning prolog, C, Java, ruby , python, forth, assembler and even
basic. Over the yeras, I've learnt a lot of languages. some were easy,
some were hard, some were easy to learn and hard to master and some were
hard to learn and easy to master. I just feel it is the process and
experience which is a greater determinant of a good programmer than lisp
and that you will find many good programmers that have never learnt
lisp. In fact, I suspect that if you analysed users of 'fringe'
languages, those that don't have a large user base or a lot of publicity
etc, you will probably find a higher ratio of "good" programmers than
you would find in something like c.l.php or whatever popular language.
>> A genuine
>> interest or sometimes even passion for programming and its underlying
>> concepts will generally produce a better programmer than someone who
>> just does it as a 9-5 job - the language is largely irrelevant.
>
> unless some unfortunate luck, genuine interest and passion will
> drive programmer to a language which is better suited for his needs.
> please don't tell us stories -- it would be very hard to satisfy
> passion in programming in some dumb Visual Basic or PHP.
>
I still find statements like this difficult to accept. they have the
feel of arrogance. Different people like different things. If my passion
was to write some great web application and the only language I know is
PHP, why couldn't I satisfy my passion using that tool? Your statement
implies that anyone who doesn't adopt something like lisp to work in has
no passion and is not a real programmer. This is just rubbish. Its like
an artist saying that if you paint in acrylic rather than oil then your
not a real artist, but just some un-talented graphic design hack.
>> I do
>> find lisp makes it easier than many languages to 'experiment' and learn,
>> but its the interest in doing that which makes a better programmer.
>
> yep, that's exactly what i was saying. i'll remind that Kenny
> wrote an essay that Lisp makes you a better programmer, i've wrote
> a reply that this factor should be less significant than
> a statistical correlation between knowing Lisp and being smart.
>
> either you have problems understanding large pieces of text,
> or you're replying to a wrong message -- you should argue with
> Kenny instead.
>
Well, actually I wasn't arguing against anyone. I was just proposing an
alternative perspective that didn't emphasise lisp as the cornerstone
for identifying good programmers and questioned the often cited 'truth'
in this group that learning lisp would make you a better programmer than
learning other languages. I actually believe learning lisp does teach
you a lot, but I also think you learn a lot from learning many languages
- particularly if they are a lot different to other languages you
already know.
I apologise if you got the impression I was attacking you personally. In
actual fact I agreed with most of what you stated originally and it was
some eof what you said that raised my ideas/thoughts that there is a
danger in over emphasising lisp as the causal link in becoming a good
programmer because you tended to emphasise the point that good
programmers are attracted to lisp. This got me thinking about the number
of good programmers I know who have never used lisp, haskel, et. al.
>> I like lisp because of its consistency and simplicity
>> compared to other languages and because it fits well with the way I like
>> to think about and solve problems. It has probably made me a better
>> programmer because it has allowed me to experiment with concepts and
>> therefore facilitated my learning and level of understanding, but that
>> is mainly due to my interest in the topic and not lisp.
>
> can you decide -- did lisp help you or not? could you achieve same
> improvement programming in VB or PHP? i guess no? then language
> matters, a little at least?
>
I believe lisp did help me to learn some concepts. However, I believe I
could have learnt those concepts with other languages as well and I
thought I made that clear in my original post.
> why didn't you stay with Ruby, Perl or Tcl? probably you have
> found something limiting about them? probably you have found
> some inconsistencies and unneeded complexity, inelegance?
>
Who said I didn't stay with them? You seem to like assumptions quite a
lot. I still use all of them on a regular basis. for some situations, I
prefer to use perl, for others, ruby and in some cases even Java and now
and again, I even use C. Every language, including lisp, has limitations
and strengths. I don't have any religious dogma for any particular
language. Often I use whatever will get the job done fastest or whatever
my collegues will find easiest to work with or whatever fits best with
how I'm thinking about the problem. Languages are tools and I like to
have enough of them to be able to select the best tool for the job. If
I've got to knock up a quick basic web page that displays some basic
information from a mysql db, I might just do it in PHP. If I need to
process a lot of log files, I might just use perl. If I need to do
something with SAX, xpath and xslt, I may use Java rather than lisp
because its all there ready to go. When I wanted to write a podcast
aggregator, I used lisp because all the library components were there -
at least I thought they were. It turns out there are so many badly
formed RSS feeds out there that rather than use a lisp based XML parser,
I got more reliable results using cl-pcre and just grabbing the
enclosures using regexps. I used lisp for that little project mainly
because I didn't really know what I wanted and it gave me the
flexibility to experiment 'on the fly'.
In fact, most of my projects don't rely on any single language. I'm
currently implementing a reasonably complex identity and access
management system. the db is Oracle and PL/SQL is used inthe
database. Java is used to connect to nonOracle databases, perl is used
for the provisioning component and at the moment, the business logic is
implemented in lisp. Not sure what the web front-end will be implemented
in yet. Two other people also work on this project. One is an extremely
talented programmer, but he doesn't use lisp and ahsn't used it since
University. He likes it as a language, but he prefers perl. the other
programmer loves C++, we give him hell for it, but I have to admit he is
a talented programmer with good design skills. I sometimes wonder if he
is so talented that its my lack of talent that prevents me from seeing
what he likes so much with C++. I had to use C++ for a time in the
mid-90s and I would have to say that while C was my first language and
as such, a language I will always have some fondness for, C++ was
possibly the most unpleasant and irritating language I've ever used (I
would have to also admit I don't see OO as being the great savior most
seem to think it is - it has its place and can be useful for some
categories of systems, but in other situations, it just feels like a
whole heap of overhead with little practicle benefit, so maybe I was a
little biased against it anyway).
> you see, probably you was able to spot issues where other
> people see none. maybe that says something about you.
> maybe you have some better programming language sense,
> better understanding about it's internal logic and structure.
> and this aptitude made you learning lisp..
>
I don't know. I find this sort of thing very hard to judge and always
feel on thin ice. I always felt like a very average programmer. However,
the more projects I work on and the more programmers I work with makes
me think the average is pretty low. Then I meet someone who really
impresses me and I realise I'm not that good after all. I rarely look at
my code and thing "wow, thats really
elegant/beautiful/clear/efficient/etc. On the other hand, I've never had
a problem I couldn't find a solution to (but maybe I'm just good at
redefining the problem - is that the sign of a good programmer or a
cunning one?)
I don't think of myself as having any great programming talent and I've
rarely been congratulated on my programming. I have recieved lots of
praise for my analytical skills and while not obvious in this thread,
have been told I have superior communication and people skills. I find
programming the easiest things I've ever done and enjoy it immensely,
but enthusiasm and sweat don't necessarily make you good. I've got a
track record of successful projects and have had no problems finding
employment, so I consider myself lucky.
Lisp is a language that I found easy to learn, but I still feel at a
novice level. I think its a language that takes a lot of experience to
master. However, this is what I really like about lisp - it makes me
work hard - I really have to think about things. It challenges me more
than most languages have. I had a similar experience with prolog. It
took me probably 6 months of daily prolog programming before the penny
really dropped - I still remember the day. Suddenly, it just all came
into focus. I've not had the same revelation working in lisp. I've
marvelled at how my code has come into focus and how much I've enjoyed
the process and at times I've enjoyed how easily I've geen able to
prove/disprove ideas and how rarely the language actually limits how I
solve the problem. However, I don't know if that has made me a better
programmer or not any more than many of the other languages I've
learnt.
> that what makes me think that some average lisper might be
> a bit smarter than average rubist -- rubist was not able
> to spot some weirdness of the language, it didn't bother
> him, he did not care about elegance -- so he might be
> a bit worse in programming languages.
>
I'm just not sure that there is any evidence that the average ruby
programmer is any less or more smart than the average lisp programmer. I
don't know what an average ruby programmer is or even what an average
lisp programmer is and have even less of an idea of what smart is.
I would be very uncomfortable making any generalisation that implies
users of my preferred language are on average smarter than users of any
other language. With ittle to back me up but my gut, I just find such
statements tending towards arrogance and insecurity. this is not meant
as a personal criticism of anyone BTW.
>> In fact, I think
>> many of the attributes that make a good programmer are language neutral
>> - the ability to aquire enough information about the problem domain and
>> abstract it in such a way to make the algorithms straight-forward and
>> possibly even elegant, the ability to ask the right questions to get the
>> right information, the ability to get inside the head of the end user,
>> the ability to consider on-going maintenance and development aspects,
>> the ability to learn and understand the subtleties of a problem domain
>> that may be very different to anything you have encountered before and
>> good communicaiton skils are all essential qualities for a good
>> programmer.
>
> yep, this is right, it is what i said to Kenny -- there is no magic
> stuff in Lisp that teaches you everything about programming.
>
Exactly, and ironically, its what set me off on my train of thought. It
was never supposed to be a direct challenge to your ideas (this is why
it was just appended at the end rather than inter-mixed with your
comments.
However, I do have (want) to say that without trying to cause offence,
the way you responded to my post actually makes me feel even more
strongly that lispers saying that lisp makes you a better programmer and
you will find more good programmers amongst lisp programmers than other
languages does have a component of rationalisation that is used to
offset the largely incorrect perceptions of lisp as an old, outdated,
slow, parenthesis ridden language that died of frost-bite in the Ai
winter.
regards,
Tim
--
tcross (at) rapttech dot com dot au
I'm returning to this long line of discussion after it has mostly
burned out, not because of a lack of interest on my part, but because
running the engineering arm of a startup doesn't really give me the
time I'd like to read/think/reply to the interesting and thoughtful
comments that forked from Kenny’s and my interchange. (One will note
that it's 5:30am!)
(I've chosen to reply to Kenny's early note here just as a random
early selection that doesn't break the rule of not replying to one's
own posts.)
Many interesting hypotheses were put forth for the reason that Lisp
programmers might (not)(appear to) be better programmers [in general/
for my particular needs]. I wish that usenet threads had a wiki page
attached to each discussion where the participants could collect the
collected thoughts (like wikipedia) so that we could gather the
various hypotheses. But the one that I actually believe got the least
attention, so I'd like to amplify it.
First, let me say that it’s almost certainly the case that the effect
is some combination of what has been said, but that mostly I'm just
wrong (my "I'm just biased" hypothesis). That said, let me run with my
second favorite, just for the sake of discussion.
As with the subject line, it's another of those that I put forth, but
as a throw away: "It's the abstraction, man..." (Or, to quote a famous
philosopher: "It's the abstraction, stupid!") More precisely, my
hypothesis here is that expert Lisp programmers, because of the unique
power of macros, learn to naturally think very abstractly about
problems. The first question that a Lisp Wizard will ask him or
herself isn’t “What is the best algorithm for this problem.”, nor
“What are the objects and how they interact?” but, rather: “What is
the most useful abstraction of this problem?” Because in Lisp what you
try to do is to create abstract representation that simplify the
problem, and then program to those.
Now, there are other sorts of abstraction that work almost in this
way. The most common example is OOP, where you ask: “What are the
objects at play in this problem, and how to they interact?” Useful as
this abstraction is for many problems, it’s just one of an infinitude
of possible abstractions, all of which are ready-to-hand to Lisp
programmers (or at least possible-to-hand), and OOP is not the most
useful one in many cases.
I have programmed in probably 25 different languages, maybe ten of
them extensively, and have invented not too few myself (which most
Lisp engineers do on a daily basis!). I’ve worked in close
collaboration with many very very good programmers of all walks, and
respect them greatly! But although I’m a very experienced (nearly 30-
year – maybe even more!) Lisp programmer, it was NOT my first
language. Given all that, still, thinking in Lisp, and working with
other Lispers really does seem to be a very different experience than
thinking in/working with other engineers. Thinking in Lisp -- with
lispers -- can be transcendent because, I believe, of the natural jump
to abstraction that we make, even about the most mundane of problems.
...and I was only partly joking about passing the joint!
I'm returning to this long line of discussion after it has mostly
burned out, not because of a lack of interest on my part, but because
running the engineering arm of a startup doesn't really give me the
time I'd like to read/think/reply to the interesting and thoughtful
comments that forked from Kenny’s and my interchange. (One will note
that it's 5:30am!)
(I've chosen to reply to Kenny's early note here just as a random
early selection that doesn't break the rule of not replying to one's
own posts.)
Many interesting hypotheses were put forth for the reason that Lisp
programmers might (not)(appear to) be better programmers [in general/
for my particular needs]. I wish that group threads had a wiki page
attached to each discussion where the participants could collect the
collected thoughts (like wikipedia) so that we could gather the
various hypotheses. But the one that I actually believe got the least
attention, so I'd like to amplify it.
First, let me say that it’s almost certainly the case that the effect
is some combination of what has been said, but that mostly I'm just
wrong (my "I'm just biased" hypothesis). That said, let me run with my
second favorite, just for the sake of discussion.
As with the subject line, it's another of those that I put forth, but
as a throw away: "It's the abstraction, man..." (Or, to quote a famous
philosopher: "It's the abstraction, stupid!") More precisely, my
hypothesis here is that expert Lisp programmers, because of the unique
power of macros, learn to naturally think very abstractly about
problems. The first question that a Lisp Wizard will ask him or
herself isn’t “What is the best algorithm for this problem.”, nor
“What are the objects and how they interact?” but, rather: “What is
the most useful abstraction of this problem?” Because in Lisp what you
try to do is to create abstract representation that simplify the
problem, and then program to those.
Now, there are other sorts of abstraction that work almost in this
way. The most common example is OOP, where you ask: “What are the
objects at play in this problem, and how to they interact?” Useful as
this abstraction is for many problems, it’s just one of an infinitude
of possible abstractions, all of which are ready-to-hand to Lisp
programmers (or at least possible-to-hand), and OOP is not the most
useful one in many cases.
I have programmed in probably 25 different languages, maybe ten of
them extensively, and have invented not too few myself (which most
Lisp engineers do on a daily basis!). I’ve worked in close
collaboration with many very very good programmers of all walks, and
respect them greatly! But although I’m a very experienced (nearly 30-
year – maybe even more!) Lisp programmer, it was NOT my first
language. Given all that, still, thinking in Lisp, and working with
other Lispers really does seem to be a very different experience than
thinking in/working with other engineers. Thinking in Lisp -- with
lispers -- can be transcendent because, I believe, of the natural jump
to abstraction that we make, even about the most mundane of problems.
...and I was only partly joking about passing the joint!
From: Paul Tarvydas
Subject: Re: It's the abstraction, man! (Was: ... brilliant engineers ...)
Date:
Message-ID: <g51imf$pkl$1@aioe.org>
Jeff Shrager wrote:
> ?What is the most useful abstraction of this problem??
I agree with this statement.
> Because in
> Lisp what you try to do is to create abstract representation
> that simplify the problem, and then program to those.
I don't think that this mindset is unique to Lisp.
Physicists (good ones) think this way. They find a notation to describe the
problem, then they use the same notation to describe the solution to the
problem. E.G. Feynman Diagrams.
In our (software/hardware) consulting practise, we often design
application / domain-specific languages to cut the problem(s) down to size.
It would seem that people who think this way, who like to solve problems by
inventing problem-specific notations, are attracted to Lisp, because it
lets them get on with the job of doing just that.
Likewise with compiler-ists. They invent problem-specific languages - and
use different tools (compiler building tools) - to get the job done.
Lisp and yacc/et al and physics-notation are tools for people who solve
problems this way.
Bizarrely, lispers and compiler-ists often shun each others' tools.
E.G. Most compiler-ists I know don't use lisp - probably because the thought
of writing RPN parse-trees (sexprs) manually offends them.
E.G. Most lispers don't use compiler tools. I am unaware of lisp macros
that employ yacc-like automata to parse their arguments. (Maybe I'm just
ignorant in this case - I await counter-examples :-).
In my opinion, the reason that Lispers are "better" programmers is that they
solve problems in a more efficient manner / on a different plane. They are
people who already understand how to solve problems this way. They
actively sought out a language (unpopular as it might be) to help them
achieve this level of expression.
pt
Paul Tarvydas <········@visualframeworksinc.com> writes:
> Bizarrely, lispers and compiler-ists often shun each others' tools.
Only for the first phases.
> E.G. Most compiler-ists I know don't use lisp - probably because the thought
> of writing RPN parse-trees (sexprs) manually offends them.
Counter example: Richard Stallman (have a look at the sources of gcc,
you might have a surprise).
But compiler-ists tend to use the language they compile to implement
their compilers, and since there's more job implementing non-lisp
compilers, they naturally use more non-lisp programming languages.
> E.G. Most lispers don't use compiler tools. I am unaware of lisp macros
> that employ yacc-like automata to parse their arguments. (Maybe I'm just
> ignorant in this case - I await counter-examples :-).
http://www.cliki.net/parser
But to parse Lisp, you don't need the complexity of a parser
generator. To begin with the Common Lisp reader algorithm is
specified in such a way that the applicability of a parser generator
is dubious. You could use one to parse the standard readtable, but
it's so simple a grammar that it's hardly worth using a generator:
it's simplier to write a parser for the standard readtable by hand.
And that said, lexing and parsing are just trivial parts of
compilation. It becomes interesting starting from the parse tree. We
already have it, and we write more compilers (or translators) than any
other programmer in average.
--
__Pascal Bourguignon__ http://www.informatimago.com/
Nobody can fix the economy. Nobody can be trusted with their finger
on the button. Nobody's perfect. VOTE FOR NOBODY.
On Jul 8, 9:08 am, Jeff Shrager <········@gmail.com> wrote:
> As with the subject line, it's another of those that I put forth, but
> as a throw away: "It's the abstraction, man..." (Or, to quote a famous
> philosopher: "It's the abstraction, stupid!") More precisely, my
> hypothesis here is that expert Lisp programmers, because of the unique
> power of macros, learn to naturally think very abstractly about
> problems. The first question that a Lisp Wizard will ask him or
> herself isn’t “What is the best algorithm for this problem.”, nor
> “What are the objects and how they interact?” but, rather: “What is
> the most useful abstraction of this problem?” Because in Lisp what you
> try to do is to create abstract representation that simplify the
> problem, and then program to those.
I completely agree that learning Lisp helps programmer gain skill,
particularly at abstraction. It's not that the great people decide to
use Lisp so much as that ordinary people who learn Lisp become better
programmers as a result.
It helps a lot if they work with other, more experience Lisp
programmers, to learn the hard stuff, such as "When it is it
appropriate and tasteful to use macros?" and other points of judgement
that are hard to convey outside the context of a large software
system.
Yes, Paul, abstraction is hardly limited to Lisp. However, Lisp has
some particularly good abstraction tools, such as CLOS and macros,
which, combined with packages (external vs. internal), when properly
used, can provide very nice abstraction support. I admit that the
"when properly used" is a real caveat. The system I work on doesn't
use packages as well as it could, and we have a project going on right
now to fix that retroactively; but it would have been easier in the
long run had we paid more attention long ago (we're talking about
500KLOC here!).