Yet another reason to avoid


I find  it strange how allows for competing projects as they don’t really position themselves as a Sourceforge or Google Code.  I know I’m pretty stupid for creating buzz about a competitor, but IBM and HP have launched a new JAX-RS effort at  The thing is, the Apache CXF project already has a pretty good certified JAX-RS implementation.  If I were Sergey or Dan I’d be pretty pissed.  This just solidifies my opinion that is a horrible place to host an open source project or to build start an open source business.

Not only do you have to worry about some Apache bureaucrat pulling rank on you or disallowing you to commit too much work to a project, you also have to worry about sharing your already diluted brand with a  competing project.  With a competing project the “Apache” in front of your project’s name ceases to add any value to the uniqueness of your project.

BTW, I don’t mean to pick on IBM and HP.  I’m just annoyed at  While it may be a great place for big vendors to collaborate at a neutral site, is just a horrible place for the little people of the world.

I also shouldn’t pick on so much.  They are a good organization with a good message and good ideals.  I just want to encourage future OSS developers to try and go at things on their own.  Learn to promote their project on their own without relying on the Apache brand.  Its better for them in the long run.

Polyglotism is the worst idea I ever heard


Let me first start off being a little facetious with a little tongue in cheek…I’m an American.  I have no need to speak another language because well, I speak English.  99% of the civilized world speaks English so WTF should I ever learn another language?  Case in point, I minored in German in college.  For two semesters I went over to Munich and worked at Deutsche Aerospace so that I could learn German better.  The thing is, besides the fact that my coworkers spoke damn good English to begin with, all the documentation they put out was in English, the units used were feet, pounds, miles.  When the French came over to work with us, we also spoke English.  So what is the freakin point of learning German?  I was pretty damn disappointed that I wasted all this time in college learning German when in reality it was just a freakin useless exercise…

Which brings me to the point of this blog.  Polyglotism in software has to be the worst idea I ever heard.  The idea of it is that you use the language that is best fits the job.  Some say this is a huge boon for the developer as they will become more productive.  In practice though, I think this is just a big excuse so the developer can learn and play with a new language, or for a language zealot/missionary to figure out a way to weasel in his pet language into a company.  Plus, you’d probably end up being average or good at many languages but a master of none….But lets pretend that it is a benefit to the developer.  Developers need to realize that there are implications to being polyglot.

Maintenance Nightmare

So, you’ve added a Ruby module to that big flagship Java application or product your company is so proud of.  You did it fast.  It works. And management loves you for it.  They love you so much for it, they’ve promoted you to software lead and now you are running a brand new project.  Now that you’ve left your polyglot project, somebody needs to take over your work.  Unfortunately, your group is a bunch of Java developers.  For any bug that needs to be fixed, these developers need to be retrained in Ruby, a new Ruby developer needs to be hired, and/or a Ruby consultant/contractor needs to be brought it.  Multiply this by each language you’ve introduced to your project.

Refactoring Nightmare

The JVM is pretty cool now.  We can run Ruby on it, Python on it, and even PHP on it.  Your JRuby apps can work with Java APIs.  Same with Jython and JPHP.  Great.  So now your developers can use any one of these language to build out extensions to your Java app.  But what happens when you want to refactor one of your re-used Java libraries?  OOPS!!!

Installation Nightmare

Ah, so you’ve weathered through the maintenance and refactoring nightmares and you’ve finally shipped your product.  Hmm, but you’ve just added the complexity of installing multiple runtimes on your user base.  Its not hugely bad if you’ve used the JVM as your base virtual machine.  But you still need to package and install all the appropriate Java libraries, Ruby gems, and Python libraries on the appropriate places of your user’s machine.  You also need to hope that all the desparate environments don’t conflict with anything the user has already installed on his machine.  And that’s just with languages running in the JVM.  Imagine if you used vanilla Ruby, Python and Java all as separate silos!

Support Nightmare

A support call comes in for your product or application.  Its obviously a bug, but where is the problem?  Is it your application code?  Your JVM?  Your Ruby VM?  Your Java library? Your Ruby gem?

All and all, let me put it this way.  We all work in multi-national environments.  What if each developer documented their projects in their own native language, because lets face it, they are most productive in that language.  Where would we be?  Doing what’s best for oneself isn’t always best for the big picture.

Obama to the rescue


I listen a lot to talk radio, specifically WEEI Sports radio, and 96.9 FM Talk Radio in the Boston area. Unfortunately, when it comes to politics, all you hear on talk radio is conservative, right wing viewpoints. I do live in Massachusetts, so don’t ask me why all this right wing propaganda pollutes our airwaves. I guess this is because right-wing politics tend to piss a lot of people off and drive up ratings. I don’t know. You got me, a liberal democrat listening to them, so I guess the ploy has worked.

One thing I heard a lot after Obama’s first address to Congress was conservatives attacking Obama’s speech and the stimulus. You hear nitpicks about how Texas is getting a cheerleading museum. Stuff like that. Showing bloat that when compared to the overall size of the stimulus package is pretty insignificant. What I wanted to do within this blog is call attention to a few of the good things that are in the bill.

Last summer I joined our Town’s Finance Committee. The Finance Committee’s job is to review all departmental budgets in town and to submit an overall base budget for the entire town. I couldn’t have picked a more interesting time to join. The economy has stalled town growth which means very little new revenue growth. Massachusetts state revenue is also way down which has put local aid funds in serious jeopardy. The contracts for our Police, Fire, and Teachers are all up for renegotiation. Add to this Massachusetts Proposition 2 1/2 which forbids local communities to raise taxes more that 2.5% without 2/3 of the town voting to support a tax increase. It has turned out to be a very tight budget year.

In a tight budget year, we all know what takes the brunt of any cuts. The school system. Our school is faced with probable cuts in funding to after school programs, children supplies, furniture, and even textbooks. There’s also the very real danger of staff reductions and increased class sizes as well as we’re dangerously close to the 2.5% threshold.

The federal stimulus package couldn’t have come at a better time and is affecting our budget in three possible separate ways

  • Special Education.  Massachusetts law requires kids with special education needs to be supported by the community and integrated with the school.  A special needs kid moving into town can have a huge impact on the schools budget as they cost a lot more than a regular student to educate and support.  For example, in our town, new special ed kids account for 25% of the growth of the schools budget.  During the Bush Administration ‘W’ set up guildelines for special education, promised funding, but never delivered.  It looks like the stimulus is providing the promised funding.  This results in hundreds of thousands of dollars being put into the school system.
  • It is not fully clear yet, but it looks like the stimulus package will help fully fund the shortfall of state education aid.
  • Obama wasn’t lying when he said our schools were crumbling.  Our 40-year old roof started leaking into a 4th grade classroom due to the severe weather we’ve been having this winter.  The kids had to be moved to another area in the building.  There is a high possibility the stimulus will help us fund putting in a badly needed roof.  Our junior high and high school also have new roofing needs that have been put off.

I know the conservatives among you will never ever admit that the stimulus is doing any good, but I hope those of you on the fence at least have had their eyes opened to some of the good.  Too often the media (even the liberal media) focuses too much on the eyebrow-raising parts of politics and never really sheds light on the true reality.  Hopefully this blog has done a little to shed some light on things.

The Answer to the Alaskan Independence Movement


Thanks Sacha for sending this too me.  Hey I would have been happy with just New England seceding!

Dear Red States:

We’ve decided we’re leaving. We intend to form our own country, and we’re
taking the other Blue States with us. In case you aren’t aware, that
includes California, Hawaii, Oregon, Washington, Minnesota, Wisconsin,
Michigan, Illinois and all the Northeast. We believe this split will be
beneficial to the nation, and especially to the people of the new country
of New California.

To sum up briefly: You get Texas, Oklahoma and all the slave states. We
get stem cell research and the best beaches. We get the Statue of Liberty
. You get Dollywood. We get Intel and Microsoft. You get WorldCom. We get
Harvard. You get Ole’ Miss. We get 85 percent of America’s venture capital
and entrepreneurs. You get Alabama. We get two-thirds of the tax revenue,
you get to make the red states pay their fair share.

Since our aggregate divorce rate is 22 percent lower than the Christian
Coalition’s, we get a bunch of happy families. Please be aware that Nuevo
California will be pro-choice and anti-war, and we’re going to want all
our citizens back from Iraq at once. If you need people to fight, ask your

With the Blue States in hand, we will have firm control of 80 percent of
the country’s fresh water, more than 90 percent of the pineapple and
lettuce, 92 percent of the nation’s fresh fruit, 95 percent of America’s
quality wines (you can serve French wines at state dinners), 90 percent of
all cheese, 90 percent of the high tech industry, most of the U.S.
low-sulfur coal, all living redwoods, sequoias and condors, all the Ivy
and Seven Sister schools plus Stanford, CalTech and MIT. With the Red
States, on the other hand, you will have to cope with 88 percent of all
obese Americans (and their projected health care costs), 92 percent of all
U.S. mosquitoes, nearly 100 percent of the tornadoes, 90 percent of the
hurricanes, 99 percent of all Southern Baptists, virtually 100 percent of
all televangelists, Rush Limbaugh, Bob Jones University, Clemson and the
University of Georgia. We get Hollywood and Yosemite, thank you.

Additionally, 38 percent of those in the Red states believe Jonah was
actually swallowed by a whale, 62 percent believe life is sacred unless
we’re discussing the death penalty or gun laws, 44 percent say that
evolution is only a theory, 53 percent that Saddam was involved in 9/11
and 61 percent of you crazy bastards believe you are people with higher
morals then we lefties.

Finally, we’re taking the good pot, too.

Peace out,

Blue States


Leave a comment

There’s three things in this presidential campaign that really made me burst out laughing when I heard them.  The first was when Vice Presidential candidate,  Sarah Palin said “Its time that normal Joe Six-pack American is finally represented in the position of vice presidency.”  Palin said if she and John McCain win, they will “put government back on the side of the people of Joe Six-pack like me.”  Do you know what the definition of Joe Six Pack is?  From the Urban Dictionary:

Average American moron, IQ 60, drinking beer, watching baseball and CNN, and believe everything his President says.

Beyond the fact that every time I hear Palin speak I think of the movie Fargo, why is this statement either appealing or reassuring to voters?  I never understood why many Americans feel they have to vote for somebody they’d feel most comfortable having a beer with or somebody “just like them”.

The second hilarious thing was when McCain started talking about Joe the Plumber.  “Joe I will fight for you.”  I was cracking up every time McCain mentioned him in the debate.  Here’s a man I actually switched parties in 2000 to vote for in the GOP primaries making a joke out of his campaign.  He feels he’s so behind in the polls he has to pull this kind of publicity stunt?  Sad, and actually quite hilarious at the same time.

The third and final belly burster is that “Joe the Plumber” is actually now campaigning for McCain in Ohio.  Who the F is this guy?  If you start reading about him you’ll find he actually isn’t really a licensed plumber and never completed the apprentice program for plumbing.  IMO, McCain should fire the campaign advisor who suggested to make Joe the Plumber a celebrity.  The guy is already stumbling and bumbling and making an ass out of himself and McCain.

All and all, this appealing to the lowest common denominator of society makes me want to secede from the Union too.  Many times I think Mike Judge got it right.

Spring Source: The drug dealer approach to OSS


Rod and Spring Source continue to make some questionable decisions on the licensing and distribution of the Spring Framework.  I’m wondering if Rod is getting some serious pressure to deliver on the more than $25 Million in VC money he’s gotten over the past 2 years, he’s plain getting bad advice, or just had an SMD moment with the OSS freeloaders out there that refuse to buy subscriptions for technology that isn’t much more than an EJB container and Struts.

I told you so!

The latest botched attempt to monetize Spring was the announcment that they would not be releasing community versions 3 months after a major release and further point releases could only be gotten from a subscription.  The Spring community was pretty pissed off as noted by this 200 post TSS Thread.

A year ago I warned you VC initiated things like this might happen to Spring when I demanded to Standardize Spring in EE 6.  Open source alone doesn’t isolate you from vendor-lockin.  Its standards + open source combined that give you true freedom.  Its why we standardized Hibernate under JPA and why we’re standardizing Seam under the Web Beans specification.

A Bad Move

The funny thing is, this money grab by Rod and company didn’t need to happen.  The move left me scratching my head in wonderment at the stupidity of SS management.  This move was stupid for two reasons:

  1. Spring Source pissed off their community for no good reason.  Developers can still get access to the latest and greatest Spring source code, but they have to build it themselves.  (And also hope the current branch is stable, but that really shouldn’t be a problem with using SVN and timestamp checkouts).  What I bet will happen is some people who haven’t tried EJB3 will try it now.  Others will simply look for an alternative like Google’s Guice framework or even JBoss Seam.  Others, with more initiative might even fork Spring.  Hey, its ASL, it could even live at!  Actually?  No, this isn’t a very big deal.  JBoss supposedly pissed off the open source “mainstream” years and years ago (2003) and this didn’t hurt our growth rate, or hinder our dominance.  Still, bad PR is bad PR.
  2. More importantly, Spring Source screwed up their ecosystem.  How?  Many Java open source projects rely on Spring to bootstrap themselves, or for integration purposes.  For example, the Grails projects uses Spring extensively.  This move by Spring Source has screwed projects like Grails that have depended on Spring to work.  The problem is that 90% of Spring (at least the 90% of what people use Spring for) is the integration it does with other third-party products and projects.  What happens to Spring if the third-party projects in their ecosystem stop using Spring to integrate?  Rod just endangered the very thing that makes Spring compelling!

A Better Way

What boggles my mind here is that this could have been done very differently.  WE DO NOT DO THIS AT JBOSS!!! WE CONTINUALLY RELEASE COMMUNITY VERSIONS OF OUR SOFTWARE. And yet, we have are are still growing like crazy.  What makes people buy subscriptions is value-add.

The biggest value add is that large organizations want to know that you are going to support versions of your software for years.  Let’s say 3-5 years after its released.  Spring Source, could have left their announcement at “We will support Spring versions for 3 years” and it would have been a huge win for them.  I know it helped our sales when we announced a similar support policy years ago.

Another value-add is what we built with the JBoss Operations Network.  JON not only gives you management and monitoring, but also helps with pushing patches and critical security updates to users as quickly as possible.  You make distribution a service that people want to pay for.

A third value-add is to give away proprietary add-ons with the subscription.  For us, what we did was license or acquire proprietary technology.  We licensed the underlying technology of JON, which we later open sourced.  We acquired technology from Excedel to help productize our Eclipse tool offering.

The fourth and final, is of course indemnification.  Where we protect you legally from lawsuits.

The Drug Dealer Approach

Instead of modeling themselves like other open source businesses, Rod had to take the drug dealer approach to professional open source.  Give open source users a free taste of pure open source smack, get them hooked, then charge them big bucks when they need a fix for their Spring addiction.  What’s sad, it just didn’t have to be this way.

@See why I’d never develop at Apache


I was forwarded a pretty interesting (and funny) email thread on Apache MINA‘s mail list.  It seems a MINA developer was upset that a particular checkin did not have @See Javadoc comments.  So much so, he vetoed the commit.

“I’m on the project *management* committee.

I would like to see the code you commit adheres to some standard.

Until this is resolved my right to veto holds so please revert your commit until we figure out the best choice for Javadoc. If you won’t revert it, I can do it for you.”

A huge flamewar ensued thereafter.  This is why I would never, ever host an open source project at Apache.  Its not because a silly flamewar happened over a trivial issue.  We had a similar one errupt over Steve Ebersole putting in SL4J in Hibernate.  Poor Steve had a few of us flaming him.  In true JBossian fashion, Steve, the project lead, basically said, “bleep you.  I’ve researched the issue thoroughly and I’ll do what I want and think is right.”  No, the actual reason I’d never go to Apache is that anybody is allowed to veto your commit via the Apache rules:

“PS : for the record, here is the veto definition ( :

*Veto* According to the Apache methodology, a change which has been made or proposed may be made moot through the exercise of a veto by a committer to the codebase <> in question. If the R-T-C <> commit policy is in effect, a veto prevents the change from being made. In either the R-T-C or C-T-R <> environments, a veto applied to a change that has already been made forces it to be reverted. Vetos may not be overridden nor voted down, and only cease to apply when the committer who issued the veto withdraws it. All vetos /must/ be accompanied by a valid technical justification; a veto without such a justification is invalid. Vetos only apply to code changes; they do not apply to procedural issues such as software releases.”

Imagine going to your boss or project lead at work and saying “I veto this commit.”  How hilarious would it be to see the look on their face?  Seriously though, democracy just doesn’t work in software development.  There are too many ways to skin a cat in software.  Its hard enough to get code released on budget and on time without some stupid random schmuck vetoing your work.

BTW, if you think this is funny, check out this old PMC complaint.  In this case, it wasn’t a developer vetoing a commit, it was some Apache bureaucrat putting down the hammer.

Anti-IDE Myths


Well, if you were wondering who my evangelist colleague was in my “Dynamic Languages: Rationalizations and Myths” blog, wonder no more. Please go read Steve Vinoski’s comments, they are a good read. One of my major points against dynamic languages was the inability for an IDE to provide reliable refactoring for them. Steve attacked this with a considerable amount of drivel. Here’s some good blurbs:

“The contrived Ruby example that Bill uses to “prove” [that dynamic languages can't do reliable refactoring] is, well, contrived. Why would anyone write code like that or suddenly get the urge to rename init to init2? I’m no Ruby expert, but I’d probably rename the method and then stick a method_missing in there to catch any call instances I might have missed with my editor. “

Contrived my ass…Like I said in my previous blog. I write sucky code. I am constantly renaming methods, extracting methods, combining methods, renaming classes, deleting unneeded methods, fields, classes all the time. I never get things right the 1st time and rarely get them right the nth time. Steve, 99% of us are not the uber programmer you are. And, what Steve? Am I going to have to do a constant edit/test/edit/test continuously until I get my edits right? Sounds a lot less productive than having the IDE automatically and reliably do it for you with one click. Again Steve, I used to be in your world. Not as long as you, but still a considerable amount of time.

“I asked him if these magical modern IDEs that raise productivity and eliminate common errors also eliminate defects caused by missing or misunderstood requirements, missed use cases, or just plain ol’ bad programming. Again, no answer. The reason I asked this is that those are the bad bugs; syntactical errors are really the least of your worries. Even if the IDE spits out common idiom/pattern skeletons for you, it’s still quite possible to screw up the code logic, and neither the IDE nor the compiler is going to prevent that.”

Nice strawman Steve. When did I ever say or infer this? How is implementing in a dynamic language going to “eliminate defects caused by missing or misunderstood requirements”? It sure is going to be a hell of a lot easier to refactor your codebase to fix these problems, but eliminate? So Steve, are what you really saying is “IDE’s are not going to eliminate your bugs or poor design”? Thanks for stating the obvious. What I keep telling you is that I’m going to be 10 times more productive with a statically typed IDE when I try to fix these poor designs and logic.

“Considering how old Java is, it’s obvious that it’s taken quite a bit of time to get these IDEs to where they are today. I asked Bill if everyone should have to wait a long time, on the order of 10-15 years, before an IDE truly becomes valuable for a given language. No answer. Personally, I’d rather stick to my emacs and UNIX tools, with their infinite applicability and flexibility that can be used for development in pretty much any language, than wait around for someone else to give me a far less functional IDE that barely addresses only one language. But then again, if one language is all you got, then I guess you have no choice.”

Reality: One, I don’t remember him asking me this. Two, I think that IDEs (at least Intellij) are so well designed now that they can easily support a variety of languages fairly quickly. Add to this fact that their APIs are open (not OSS, but open) and have a great community. For instance, on a quick search I found plugins for Ruby, Python, AspectJ, XML, XML Schema, and Scala. The interesting thing about Intellij, is that it also has support for frameworks. For example, it has syntax checking and code completion for embedded Hibernate/JPA QL. Refactoring integration between Spring, JavaEE and Java. I haven’t looked at their RoR support, but I bet it is awesome. I continually find it AMAZING how these guys bang things out. They are either an army of people (doubtful) or just have an incredibly architected product (probable).

“I asked Bill if he’s ever considered that Java IDEs are the way they are due to issues with the Java language itself that must be compensated for. Consider its verbosity, for example, which is why IDEs spit out those skeletons.”

Reality: Let me go through the list of Code Gen and Refactoring items and see what is not useful in, let’s say, Ruby. There are 30 refactorings in IntelliJ + Java. Only 8 out of 30 are NOT useful to Ruby. For the “Generate..” code generation tab. 2 out of 5 are not useful for Ruby. I think the “Surround With..” tab is useful. The thing is, out of these 35 things, I *DO* use one of them *at least* every 10 minutes. This is of course assuming you believe that the unuseful things are because Ruby is a better language (I don’t beyond the closure stuff). I will admit that only 5 of the refactorings require a statically typed language to be *reliable*, but, at least for me, I do use these particular ones very very often, especially after the first prototype. (rename, move, safe delete, change method signature, inline). At least with Intellij, parameter types are also extremely useful with code completion. Good code is self documenting and with IDE code completion, I don’t have to look at a manual or source code comments to find out how to execute a method on an object. BTW Steve, what “skeletons” are you talking about? MDA bullshit? Or the crap I rarely use?

“Saying that “my buddy Jason was on a team that had to put type names in their Python function names” is certainly not even close to being solid evidence of your claim, Bill.”

Steve, I think Jason’s experience was a relevant experience.  I wrote about it because  I thought Jason’s experience was the funniest story I’ve heard. It sure isn’t the only horror story people have had with lack of static typing.

Other dynamic language propaganda


One of the commenters of my last blog reminded me of yet another myth:

If you learned to code in the XXX dynamic language way you’d need to rely a lot less on your IDE.

And Joe Johnson wasn’t the first to say that to me.  :)  Another tactic I can’t stand with the zealots in the dynamic language community (and any other religious communities I might add.)  Attack your criticizer’s insecurities.  This comment translates to, “Java has made you a sucky programmer, if you program in Ruby, you will no longer be a sucky programmer” Or, simply:  “Ruby will make you an UBER programmer”  or, even simpler “You are a sinner, you must be saved”.  This is an awesome way to promote your language.  Why?  Well, because most of us programmers are geeks.  We were laughed at in school for wanting to spend our free time copying game code from magazines.  Even beat up.  So, we are inherently insecure and eager to be accepted by any crowd.

The problem with this argument is, for me personally, what happens when I switch to Ruby and miss the productivity I had with my Java IDE?  Does this mean I’m a horrible programmer and still a loser?  You readers know how insecure I am.  So, I just can’t switch to Ruby.  When I fail at becoming the uber programmer I always wanted to be after switching to Ruby, my insecurities and closet-Rod-Johnson-loving, fragile ego will just shatter me and I will end up  crying myself to sleep every night.  Sorry no thanks.  I already had enough heartache watching the biggest choke in NFL history yesterday.  I can’t take anymore.  The reality is that I know I am a horrible programmer and switching to Ruby won’t change that fact.  At least if I stay with Java, others will have the tools to productively clean up the messes I leave behind.

Ruby jobs have grown 500%!

Many are still scared by the bubble burst.  Many were laid off at least once.  So, its only natural to prey on these types of insecurities as well.  The reality is, if you read the fine print, Ruby is still only a tiny percentage of the Java market.  Even if it continues at this growth rate it will be at least 3 years before it overtakes Java.  Which is fine for me as, about that time, I have to start looking for another job as, obviously, SpringSource will have put JBoss out of business by then.  I’m fine with that.  3 years is enough time for me to collect the rest of my stock and get my wife back to work to take care of my ultimately unemployed ass.

The non-programmers of the world need a simple language to code in

Beautiful!  You mean my 94 year old grandma can help me code?  The problem with this is that this leaves a huge mess to clean up after the fact.  That’s great for the $100-200/hour consultant out there cuz they can bill thousands of hours.  Sucks for the company paying the bills.

Dynamic Languages: Rationalizations and Myths


The Patriots loss in the Superbowl has gotten me so depressed and down that I need to take it out on somebody. I need to rant about something, so why not about some things that have annoyed me over the past few months about the dynmaic language community.

I recently emailed the mandelbrot benchmark to a dynamic language evangelist colleague. Although benchmark results are usually pure propaganda, poor representations of how a language or framework is used in the real world, or even just plainly out of date with the latest versions of the technology, still, the performance of dynamic languages compared to Java in the example is quite embarrassing. Ruby, for example, is 500 times slower! Yeah, its hard to take seriously a benchmark that outputs to stdout, but still, if you look at the code you’re thinking, WTF is Ruby doing that causes so much overhead?

Now, when I forwarded this benchmark to my evangelist colleague, he immediately accused me of trying to put down or stamp out any challenge to the “One True Language” (Java). Its not about putting down or stamping out. Its about testing whether or not a language is a viable application platform. The thing is, if the dynamic language crowd is going to position itself as a replacement for Java in application development then they are going to have stop giving silly rationalizations for their shortcomings and promoting myths about their language and Java. This, and this alone is what irritates me about this crowd. Let me give you some examples about the rationalizations and myths they try to pull over on us:


Dynamic Language XXXX didn’t do well against Java in XXXX benchmark

Rationalization: “Benchmarks indicate very little practical information about the overall utility and performance of a given language or runtime.”

Reality: Although benchmarks are either propaganda, out-dated, or not a good representation of real-world usages, glaring differences must be recognized. A 5%, 10%, or even 100-200% difference is probably as a result of tuning or some simple undiscovered bug. In the grand scheme of things, those kind of numbers ain’t very relevant. But a 50000% difference? For such a simple benchmark? Something is seriously wrong here.

This reminds of 2002, when I first ran JBoss against the J2EE SpecJ benchmark. We had some pretty embarrassing numbers at first way back then. Although SpecJ is clearly a silly, non-real-world benchmark, it allowed us to identify many major and minor bottlenecks and helped our project to mature. For some dynamic languages like Ruby, I think what the mandelbrot benchmark showed was that the VMs/implementations of dynamic languages like Ruby are still very immature compared to Java. I don’t believe that it shows anything seriously wrong with the language syntax of these dynamic languages themselves though. Java received similar attacks in the mid 90s when it came out. Since then, the JVM has improved dramatically and according to the mandelbrot benchmark, only 10% slower than C. I expect the same out of the Ruby guys eventually. I’ll have to see how this benchmark improves under JRuby.

Ruby VM cannot support kernel threads

Rationalization: “Green threads are good enough.” OR: “Who cares, I can just run multiple processes.”

Reality: Even the basic laptop nowadays has parallel computing power. Green threads don’t take advantage of this. Blocking I/O also creates huge problems with Green Threads. Solving the problem by running many processes is a poor solution. A process is just too heavy weight compared to a thread which is why we have threads in the first place. It is very common for server-side Java applications to service hundreds of concurrent users. Besides, running multiple single-threaded processes starts to negate some of the benefits of simple design patterns like caching.

If dynamic languages like Ruby want to position themselves as a viable alternative to Java for an application platform, they are going to have to solve these issues. Many will say, “Its probably good enough for simple apps”, but it is not uncommon for project leaders to underestimate how much traffic they will get, or how much they have to scale.

Dynamic languages like Ruby, Python, etc… are not typesafe/statically typed

Rationalization: “Type-safety makes my code too verbose and makes me less productive.”

Reality: Why can’t these people learn how to type? Modern IDEs make this point totally moot with code completion and code generation. Besides, why can’t we have a dynamic statically typed language?

Lack of type safety doesn’t scale well to large teams

Rationalization: Anybody noticing the “Any software written by a large team will ultimately fail.” articles floating around in the community? Am I paranoid, or is this yet another attempt at brainwashing us into believing dynamic languages are the next fad in software development?

Reality: There are a lot of large applications in the industry being written. This reminds me of a story my colleague Jason Greene told me. He was working on a very large python project. Lack of static typing ending up being such a coordination and maintenance problem they ended up having a coding policy where everybody had to embed type information into the variable names of method parameters. Funny, eh?

Lack of static typing does not allow for reliable refactoring in modern IDEs

Rationalization: “The productivity of dynamic language XXXX makes refactoring irrelevant. Anyways, there are IDEs for Ruby out there that support refactoring”. OR, my favorite: “I don’t use an IDE, what do I care?”

Reality: I was a VI/Emacs user up until 2002 when Intellij came out with refactoring capabilities. Up until then, I was as productive with emacs, find, grep, and sed as I could be with any IDE out there. After finally becoming familiar with Intellij and its refactoring capabilities, I found that I was 5, 10 times more productive with my IDE than I was before. Now, Ruby fanboys will argue, “Intellij and Netbeans have refactoring capabilities for Ruby!” My answer is, it is not reliable refactoring. Take this example Cedric Beust gave on a recent TSS thread:

def f1(o)

def f2(o)

class C
  def init

class D
   def init

If you rename C.init to C.init2, how can the IDE know which o.init must be renamed in f1 and f2? The IDE could either do these refactorings automatically (dangerous) or prompt you to confirm at each replacement point (tedious). In either case, any productivity you’ve gained with the elegance of Ruby is lost 10 times over.

So, these are just some of the rationalizations the dynamic language crowd gives when confronted with criticism. Now let’s talk about some of the myths and propaganda that is being fostered.


Software Engineers should use the best language for the job

Reality: I don’t know about the rest of you, but throughout my career I’ve either been developing middleware or writing applications. What other job is there really out there? Or maybe they are saying, “XXX dynamic language is good enough to solve certain application requirements”? Good enough has never really been good enough for me.

Besides, its hard enough to find an expert in one language. Its a maintenance and integration nightmare to have a project written in multiple languages. This can be bridged, to a degree, with dynamic language implementations that run on the JVM: JRuby and Jython are good examples. But unless these implementations become mainstream, they can quickly become out of date, i.e. Jython.

More lines of code means more bugs, thus dynamic languages are better.

Reality: Modern IDEs fills this gap. TDD is viable in type-safe languages too! I’m probably doing my own rationalization here, yes… JBoss 5, for example, is the 3rd major refactoring of the JBoss Application Server that I’ve lived through. I just can’t imagine doing it without the reliable refactoring that modern Java IDEs provide.

I am more productive in XXX dynamic language because the syntax is cleaner, more elegant, and more powerful.

Reality: Because Modern IDEs with a statically typed language can do reliable refactoring, this productivity gain has diminishing returns as your project gets larger. Even with small, one man projects, this reliable refactoring offsets any productivity gain you get with the dynamic language. At least, that’s what I’ve experienced.

I’ve done a decent sized project in Python before. I did find I was more productive with the first implementation. The problem is, I’m not a very clean programmer, so I end up iterating and refactoring constantly. In my case, a powerful IDE has made me incredibly more productive. Something I just could not get with a dynamic language.

Am I just a Java fanboy?

Maybe, but I don’t think so. Throughout my career I’ve done projects in Pascal, assembly, C, C++, Fortran, Tcl, Perl, Python, Visual Basic, Java, and even hacked around a little bit with PHP. While I don’t believe that Java is the one langauge to RULE THEM ALL, I do believe it is vastly superior to anything out there to build applications with. I also do not believe that Java is the end all, be all of existence. It still needs elegant, typesafe closures to complement annotations as a way to implement DSL. It needs a standard, non-code generating way of adding behavior to annotations. It needs a structural syntax to make initialization easier. AOP support might be nice too, or at least JVM support to make it easier to implement AOP-like features. Better zero-turnaround development features in both the JVM and APIs like Java EE, Seam, Hibernate, Spring, and JBoss AS would help out tremendously as well. Really, I’d be fine to dump Java for a language that supports all these things but the new language must:

  • Be typesafe, statically typed
  • Have an IDE that supports the same features as modern Java IDEs
  • Have a rich set apis and libraries to build my applications from
  • Have a viable commercial ecosystem
  • Have a vibrant open source community

While current dynamic languages do have some of these attributes, none contain all, so until then Java is my choice and I will remain a boy who is a Java fan.

Finally, I hope you realize that I’m not trying to stamp out dynamic languages, but rather hoping, in vain, that the dynamic language community admits their faults. I do wish that a statically typed dynamic language would come of age, but until then, I’ll stick with Java. Really, I don’t know why somebody hasn’t done it it. Is static typing really that hard to implement well? For example, why not gut Groovy and have Dynamic Java? Or do the same with Scala? Or add static typing to Python and get Jython up-to-date?

Well thats it, expect more ranting in the next few weeks/months on a variety of subjects. Its gonna take a long long time to get the Pats loss out of my system….

Edited: 2/22/08

Many people have been confused on what I meant by statically typed dynamic language.

1) Typesafe introductions/mixins to either an instance or a class

For example:

class Foo {}
class Mixin implements MixinInterface {}
Mixin.add(Foo.class, new Mixin(), MixinInterface.class);
Foo foo = new Foo();
 MixinInterface intf = (MixinInterface)foo;


Foo foo = new Foo();
Foo bar = new Foo();
Mixin.add(foo, new Mixin(), MixinInterface.class);
(foo instanceof MixinInterface) == true
(bar instanceof MixinInterface) == false

2) Ability to do AOP things like field/method/constructor interception without having to do bytecode magic
3) Ability to plug in at runtime annotation processing (not the Javac crap).
4) An instrument library that allows you to make schema changes to classes. (didn’t state this before)

Older Entries Newer Entries


Get every new post delivered to your Inbox.

Join 691 other followers

%d bloggers like this: