Tuesday, October 18, 2005

Startup school

I attended Paul Graham's Startup School this past Saturday. (Thanks to Drew Houston for letting me crash at his place!) I took fairly detailed notes on the speakers; I think this is the most comprehensive overview available, actually. (Note that these are in the order they actually spoke, which isn't quite the same as the plan.)

  1. Langley Steinert, entrepreneur. Short "entrepreneurship 101" talk. Lots of interesting Q&A.
  2. Marc Hedlund, Entrepreneur in Residence, O'Reilly Media. Talks about over a dozen startups he's seen in the last couple years -- most of which you'll recognize -- and why they succeeded.
  3. Qi Lu, VC at Yahoo. One subject: Why yahoo rocks. Total advertorial; skip this one unless you're a yahoo fanboy.
  4. Hutch Fishman, part-time CFO for startups. Talks about VC founds, directors, liquidity. Pretty basic stuff if you've read up on this at all, but his Q&A is worth reading.
  5. Paul Graham, author of entrepreneurship essays, VC, and Lisp fan. This was my first time seeing Paul speak; I was surprised to find out that when one of his essays says "... derived from a talk at ..." it really means "I read this essay at ..." So you might as well read the transcript instead of my notes, up until the Questions section. (Respect to Reg Braithwaite, who stood up to challenge the conventional wisdom that entrepreneurship isn't for people with kids.)
  6. David Cavanaugh, lawyer. Standard slashdot-style IP overview. If you know what the differences are between patent, copyright, trademark, and trade secret, you won't see anything new here.
  7. Michael Mandel, economist. Before the lunch break, I told my friends that this talk was either going to be very interesting or very dull. I'm glad I was right (and it wasn't dull). One of his points is, "The USA has certain systemic advantages that encourage entrepreneurship and growth." But I hesitate to call that his main point, since he talks about a lot more than that. Worth reading.
  8. Steve Wozniak. Sort of a retrospective. I don't know that I learned much, but hey, I got to shake Woz's hand.
  9. Mark Macenka, IP lawyer. Somewhat more useful than the other lawyer's talk. Read the "Founders issues" section.
  10. Stan Reiss, VC. Interesting take on startups from a VC's perspective: when taking VC money is worth it, and when you shouldn't. Long Q&A session.
  11. Stephen Wolfram, founder of the Mathematica company. I figured when I saw shots of cellular automata on the projector while he set up that this wouldn't be about entrepreneurship, and I could tune it out. I was right.
  12. Chris Sacca, head of new business development for Google. As much of a cheerleader as Qi Lu was, but less blatant and more interesting.
  13. Olin Shivers, professor and entrepreneur. Talks about failure and attitude in a Nietsche-ish way. Moved really, really fast; Olin was the only speaker I felt like I couldn't keep up with, note-taking-wise. Catch the video when it goes up. (If you just look at his slides, you'll miss a lot.) Excellent talk.
  14. Summer founders, the guys (all of them were male) who took seed money from Paul's VC firm. Probably most interesting if you're college-age-ish and also thinking about applying to Y Combinator.

See also the slides for those presenters who had them. Supposedly videos will be up eventually.

Of the other blogs I've seen, Fred Ngo's and Robbie Allen have the best speaker coverage.

Thanks to Paul and the speakers for organizing this! I had fun and learned a lot.

Sunday, October 16, 2005

Why I never got into Lisp

Like many programmers (I suspect) who hear enough Lisp afficionados talk about how great their language is, I've given Lisp a try. Twice. I didn't make much headway on either occasion.

For various reasons I was poking around python/lisp in google tonight and I came across this thread from a couple years ago. This crystalized it for me:

now compare
        if x > y or a == 0:
            a1 = m * x + b
        else:
            a2 = m / x - b

with
        (if (or (> x y ) (zerop a))
            (setq a1 (+ (* m x ) b )
            (setq a2 (- (/ m x ) b )).

In this case, Lisp requires about 33% more typing, almost all parentheses.

And, oh yeah, I forgot, aside from the parentheses, the pervasive prefix notation can be a drag.

Syntax does matter. Everyone who has run screaming from a steaming pile of Perl understands this. Lisp's syntax isn't the train wreck that Perl's is; at the very least it's consistent. I could get used to it if there were no alternatives.

But Lisp syntax was designed 50 years ago to make it easy to parse! We don't have to optimize for this anymore -- it's time to optimize for the programmer!

Today, Python and others have the features that made Lisp powerful without the syntactical baggage. Python has its own advantages, too, such as one of the best-designed standard libraries around. (Hence Paul Cannon's Lisp-to-python-bytecode compiler.)

Further reading: On the Relationship Between Python and Lisp.

Thursday, October 13, 2005

Why do Java programmers like Ruby?

As a (mostly ex-) Java programmer myself who prefers Python to Ruby, I'm puzzled by what seems like a rush of Java programmers to embrace Ruby as though it were the only dynamic language on the planet.

I understand that it's mostly because of the success of Rails, which definitely came at the right time with the right marketing. But Ruby really doesn't seem like a good philosophical match with Java to me.

Java, to a large degree, tried to be "C++ done right." That is, C++ without all the misfeatures that seemed good at the time but whose benefit turned out to not be worth the cost in complexity for developers. Java is a very orthogonally designed language; there is usually one obvious way to accomplish something. Python shares this. Ruby, OTOH, takes the C++ and Perl philosophy of "there's more than one way to do it," with predictible effects on maintainability. ("Perl," said a former co-worker to me yesterday, "is the drunken frat boy of languages.")

I could point at other areas where Python seemed like a better fit to me, like real threading support, etc., but the core issue seems to be: what is the language's philosophy? Is it trying to help my team write maintainable, readable code, or is it more interested in being "clever?"

Java and Python were designed for readability. C++ and Ruby were designed to be clever.

About the only thing Ruby has going for it, from this Java developer's perspective, is braces. Ahh, comforting braces. Are people that afraid of syntactical change?

I guess now I know how Lisp developers feel, a little.

Tuesday, October 11, 2005

Microsoft invents significant whitespace

Brace you must
     Written it is, the Console. “Hello World”

YODA the programming language

Wednesday, October 05, 2005

John Siracusa on C# and Java

John, of course, writes the OS X reviews for ars technica. (If you haven't read these, you need to. His level of detail should make lesser reviewers think hard about finding another career.)

In his blog, he's been talking about what Apple needs to do to avoid another Copland scenario, i.e., avoid resting on their OS X achievments only to wake up in 2010 and realize, "Oh crap! It's WAY easier to write apps for Windows than for OS X!"

Which is a rather long introduction to the quote I liked so much:

My instincts tell me that both C# and Java are too low-level. Yes, they both have fully automatic memory management, and both eschew C-style pointers for the sake of safety and security, which is more than can be said for Objective-C. But the runtime that Objective-C uses to do its "object stuff" is arguably higher-level than either C# or Java, both of which still seem to cling to charmingly retro notions of compile-time optimizations and "efficiency through bondage."

Bondage. That's what non-dynamic languages feel like to me now. No duck typing? No freedom to modify and create classes at runtime? Bondage.

Sunday, October 02, 2005

APIs matter

Victor Moholy:

A bad API, like a bad novel, feels like a trick: key information is withheld and simple relationships are hard to deduce.

I had one of those "a-ha" moments reading this. ("A-ha," I thought. "I feel a rant coming on.") This is exactly why, after building probably one of the largest web applications done with OpenACS 3.2, I never managed to like the 4.x (and now 5.x) series of that toolkit.

OpenACS 4.x and later suffer from Second-system syndrome. The effect is rather Zope-like: instead of a learning curve, you have a vertical cliff to scale before you can accomplish anything interesting.

Add in bizarre and arbitrary api changes, it's no wonder nobody except the core team really got on board with the later OpenACS versions. (I suspect that the "everything must be a named parameter" had its genesis in the proliferation of functions taking over a dozen parameters. Deprecating all functions that don't require named parameters is both taking things too far, and fixing entirely the wrong problem!)

Which is a shame. OpenACS solves a much larger problem than most web toolkits attempt, giving you registration support, permissioning, etc. out-of-the-box. The 3.x series may have solved only 90% of the problem, but it did so in a much more approachable way than 4.x. (Or Zope, the only other framework that really tried to tackle this problem in that era. Don't even get me started on J2EE systems.)

Ah, well. RIP, OpenACS. It looks like Django is trying to solve some of these same problems (e.g., its permissioning support and "pluggable applications") while retaining a more lightweight approach. In this respect, Django is much more than a me-too "Rails for Python." Of the would-be Python Rails killers (and Rails itself), Django alone impresses me for attempting more than the same old, same old.

(Which reminds me -- I haven't seen this fellow's django-and-rails comparison linked anywhere, even though it's a month old. Guess I don't follow the right blogs. It's worth reading if you don't know much about one or the other, despite his lamentable lack of taste in prefering Ruby.)