Request for comment: follow-up to Summer of Code
- From: matthewknox@xxxxxxxxx
- Date: 28 Jun 2005 21:55:38 -0700
Hi all, I'm a LispNYC guy. We just recently got 9 projects accepted by
google for the Summer of Code, but we have some slack mentoring
capacity, and a couple of really important projects to push. So I
thought it might be a good idea to try to grab up some of the talent
that did not get selected for google SOC, and try to match the talent
with mentors with more brains than time. This is the announcement I
will post to the google summer of code discussion board, and a few
other places. I would love to have your comments, criticism, and
project suggestions.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Coders of summer!
Some of you might be considering at this very moment what to do with
the rest of your vacation season. If so, you should apply to the
LispNYC Summer of Lisp!
We are not giving away money, but we offer the chance to work with
great mentors on terribly exciting projects that will knock the socks
off of prospective employers, fellow coders, and in some alternate
realities, cuties at bars. There is even a job involved for one lucky
applicant! For details, read on!
What was that about a job?
Franz, a major lisp implementation vendor, wants to embed a lispy
language in Firefox as a plugin, so that people who want dynamic
webpages can use something more powerful than javascript. They want to
get someone to work on it for the summer with them out in California.
We like the project, so we are helping them get the word out.
Where can I apply?
http://www.lispnyc.org/summerofcode.html
Who is eligible?
Anyone. We will give preference, all other things being equal, to
those who commit to a lot of time, so students have a leg up there. But
anyone may apply.
Can groups join?
Of course!
If you are not giving money, then what do I get?
I run a lot better with a coach, even if he knows nothing about
running. Just having someone to help keep me motivated is a win. We
will mentor you, direct you toward problems that we know are a big
deal, and get the fruits of your labor more exposure after the project
is done. That, and T-shirts.
Will you guys teach me lisp?
Nope. But we will point you in the right direction for teaching
yourself.
What kind of projects are available?
Compiler optimization, new language implementations both of and in
lisp, libraries, porting, and whole new applications. Computer
scientists found out a while back that the lambda calculus is good for
just about everything, and lisp is one of the better approximations to
the lambda calculus out there, so it is pretty good at just about any
domain you care to consider.
I have a project that I would like to suggest and mentor.
Great! We can always use more.
Why are you doing this?
Read The Long Tail. There are lots of projects that are not worth
spending a bunch of money on, because they are too risky, or not a big
enough win. They are still a good thing to do, both for the
implementor and for the world at large. We think there are a ton of
potential mentors in the lisp commmunity, and a ton of people who would
gain greatly from exposure to the language and the projects, and we
would like to release that value into the world.
Why should I do it?
Because you can.
Why Lisp?
You can stretch your brain by learning hard new things that don't have
lots of garbage in them. Memorizing the Manhattan phonebook or the
java class library specifications does not make you smarter, but
studying physics probably does. Lisp is a little bit like physics in
that does not require much memorization of detail but has lots of big
new concepts, many of which are present in diluted form in more common
disciplines/languages.
No really. Why lisp?
A programming language is a lot of things, but the most central is a
pipe between your messy, biological, analog head and certain kinds of
discrete math, usually machine code. Some programming languages, like
C, assembler, and fortran, are very close to the actual details of some
actual machine. Others, like Haskell, Python, perl, and so forth, are
much farther away from any actual machine, but are closer to your head,
and so are a lot easier to program in, because you can think more about
your problem and less about the machine. The lisp family of languages
is unique in the degree to which it allows you to be both close to the
machine and close to pure thought-stuff in the same language, sometimes
even in the same program.
As an example, if you have a bunch of things, and you want to apply
some function to all of the things, you can say:
(map function things)
That is exactly what you wanted to compute. Nothing more, nothing
less.
On the other hand, Common Lisp is just about the only language that has
a disassembler required in the language spec, and if you use that
disassembler to check out the code that a properly tuned lisp program
puts out, it turns out to be very close to the assembler that a very
good C compiler puts out, only without the buffer overruns and memory
leaks. (We're working on an emulation package to keep the C guys
feeling at home. )
So Lisp gives you most of the advantages of high-level languages like
python and most of the advantages of low level languages like C in one
language, but it also gives you some things that other languages cannot
in any reasonable way.
If there were some expensive operation that returns a true/false
result, and you were only interested in the majority vote, you might
want to stop when you have already gotten a majority, the same way you
stop evaluating when you get to a false result in an AND, or a true one
in an OR. The interface should look like this:
(majority TRUE TRUE TRUE x y) => true, without actually evaluating x
or y. If you frequently deal with a large set, most of which will turn
out either true or false, then having this in your toolbox could help a
lot. Exercise for the reader: implement this in whatever language you
want, such that people can say
(majority (expensive-function-call) (long-running-query-to-db)
(get-user-input) and the user only gets asked for input if the first 2
arguments evaluate to different values. Hint: it involves massive
pain, and requires the users of the function to do things a little (or
a lot) differently to make it work.
.
- Follow-Ups:
- Re: Request for comment: follow-up to Summer of Code
- From: Matthias Buelow
- Re: Request for comment: follow-up to Summer of Code
- From: beliavsky
- Re: Request for comment: follow-up to Summer of Code
- Prev by Date: Re: ILC2005: McCarthy denounces Common Lisp, "Lisp", XML, and Rahul
- Next by Date: Re: Accelerando
- Previous by thread: Accelerando
- Next by thread: Re: Request for comment: follow-up to Summer of Code
- Index(es):
Relevant Pages
|
|
