407 karma · joined December 1, 2010
I just found a thread I started about ActiveMQ and scaling:
http://activemq.2283324.n4.nabble.com/6000-ActiveMQ-clients-...
Note the last message there. 36,000 threads when using NIO! And these answers were from the people commercially supporting ActiveMQ (FuseSource). I never did find out (on that thread or elsewhere) whether ActiveMQ has ever been used in a situation that large. I suspect it hasn't.
We ended up writing a new queuing system from scratch in a month, and in its first week it was already more stable, performant, and bug-free than ActiveMQ.
Sure, but after 55 years of Lisp, that hasn't happened. If Lisp is unused because programmers find it hard to resist using a feature anti-socially, then it's time to change that feature.
Of course I have no hope that Lisp will change its macro feature. My interest is in making sure that new language designers realize that Lisp's so-called perfection is the very reason that it languishes.
Thinking about it more, I might describe macros as "anti-social" in that they help the programmer but hurt the team. This might be what you meant.
Note that I'm not saying that the idea of macros is bad; only that Lisp's decision to make them look like function calls is bad. I once saw a macro system for Lua that made their invocation look clearly different than normal language.
I'm not claiming this is the main problem with Lisp; only that it's one of them.
Being write-only would explain why there are so few collaborative Lisp projects.
And I don't particularly buy the thesis of this essay that there are few collaborative Lisp projects because it's possible to do anything with a single person. You can always find sufficiently difficult problems that would require a team. Projects in Lisp should be putting projects in other languages to shame. I think there's something about Lisp that makes collaboration too difficult, and I suspect it's the expressiveness itself.
A "B" coder is one who for the most part writes good code, but doesn't design a good long-term architecture, or makes many small mistakes that add up in the long run, or leaves the code riddled with small bugs that eventually cause frequent problems. The "B" coders are the dangerous ones because really you should fire them or fix them, but it's too easy to ignore them.
An "A" coder writes solid code and is dependable, but doesn't hit the high notes, as Joel Spolsky says.
A star coder is an "A" coder who hits the high notes.
(I don't know what a "D" coder is, but perhaps our scales are offset by one letter grade.)