Introducing Sproiiiing: the Hottest New EoC Framework
The last few years have been an exciting time in the Enterprise Java world. We’ve seen a proliferation of lightweight application frameworks that vastly simplify the wiring of applications without introducing dreaded dependencies into our precious class hierarchies.
But these frameworks still fall short of the mark. Every time you use an import statement or define a new class, you place a burden on the consumers of your application. Import statements create dependencies on other classes in your project. The existence of specific methods and (even worse) classes, constrain the functionality of your application to the features defined at compile-time by your developers.
Based on these unacceptable constraints, I’ve been working hard on a new “Elimination of Code” framework (EoC), and I’m proud today to announce the availability of the Sproiiiing framework!!!
To give you an idea of the power I’m talking about here, take a look at this code:
MyApplication.java:
package net.benjismith.enterprise;
class MyApplication {
}
What you’re looking at is the entire source code for a scalable enterprise solution capable of implementing any functionality required by your demanding clients. Once compiled, the entire behavior of the application can be modified using a simple XML configuration file, without adding any dependencies to the core application.
A simple hello world application can be deployed using this ridiculously lightweight XML configuration file:
ApplicationContext.xml:
<sproiiiing:class package="net.benjismith.enterprise" name="MyApplication">
<sproiiiing:method returnType="void" visibility="public" modifier="static" name="main">
<sproiiiing:arguments>
<sproiiiing:argument type="java.lang.String[]" name="args"/>
</sproiiiing:arguments>
<sproiiiing:statements>
<sproiiiing:method-invocation class="System.out" name="println">
<sproiiiing:arguments>
<sproiiiing:argument type="java.lang.String">
<sproiiiing:string-literal><sproiiiing:![CDATA[Hello World!!]]></sproiiiing:string-literal>
</sproiiiing:argument>
</sproiiiing:arguments>
</sproiiiing:method-invocation>
</sproiiiing:statements>
</sproiiiing:method>
</sproiiiing:class>
</sproiiiing:application>
When the application container initializes, it will instrument the MyApplication class file, inserting all of the necessary application bytecode, thereby eliminating the need for application developers to actually author any code. This revolutionary technolgy finally achieves the decades-old objective of serious computer science: to develop an environment where even the most complex functionality can be implemented with the minimum possible authorship of code: none.
Unlike traditional application frameworks, which can require expensive software engineers to spend man-years writing hundreds of thousands of lines of code, the Sproiiiing framwork allows the entire application to be developed by business analysts editing configuration files on their Blackberries!!
As you can see, this framework completely eliminates ALL CODE and ALL DEPENDENCIES from all possible software projects.
Clearly, this makes Sproiiiing the most lightweight Enterprise Java framework ever introduced into the market!!!
NOTE: I would publish a link to the downloadable binary files for this incredible framework, but doing so would introduce an unnecessary dependency on the target of the actual URL.
May 3rd, 2007 at 3:52 am
This is a nice joke, making frameworks as powerful (generic) as programming languages.
May 5th, 2007 at 6:07 am
“…ridiculously lightweight XML configuration file”
Oh yeah, its really ridiculous. The no-meaning “sproiiiing” word appears 20 times!
“…o be developed by business analysts editing configuration files”
But they still need to know Java - to code those configs.
“…Clearly, this makes Sproiiiing the most lightweight Enterprise Java framework ever introduced into the market!!!”
Blah-blah-blah. I clearly don’t buy this s%#t. Period.
May 5th, 2007 at 8:41 am
Whooooosh!
May 6th, 2007 at 2:47 am
@S.J, I guess you need to improve your sense of humor.
May 10th, 2007 at 8:46 am
Wasn’t this supposed to be posted on April Fool’s day? No really, you have still not outdone your famous Frameworks essay.
May 14th, 2007 at 1:35 am
Very nice joke .. I found it refreshing to be reminded that I’m not alone in not being fond of XML push ups. Although it might be that XML push up are like real push ups .. which are good for you, but unpleasant for those who isn’t doing them regularly :)
@S.J. thank you for being (unintentionally) funny as well :)
July 6th, 2007 at 1:56 am
Yes, where can I download!? ;)
It is frightening the trend we’ve been having where people think that:
is somehow more flexible/readable/maintainable than:
if (expression) { doStuff() }
August 1st, 2007 at 11:37 am
The problem is…there’s no XSLT file to dynamically generate an interpretation of the GUI.
August 7th, 2007 at 12:08 pm
For a geek, you have amazing sense of humor! BTW, I added you in my NetFlix friends, I hope you don’t mind.
August 8th, 2007 at 9:04 am
So that was you!!
I got the netflix-friend email yesterday and, obviously, I didn’t recognize your name.
Nevertheless, I wondered if I actually knew you from somewhere but had forgotten your name. (I’m like that. I tend to forget people’s names shortly after I’ve met them.)
I almost feel like we should have a cup of coffee or something first, before I let you peek inside my netflix account. :-)
August 10th, 2007 at 11:08 am
Thanks! This helped me alot in understanding the true benefits of XML. Lightweight IS the way as you clearly demonstated it!
September 4th, 2007 at 6:27 pm
I am afraid your humour is no longer funny. I discovered your “frameworks” essay yesterday, and I was entertained - even though I do not agree with you at all - because your post did at least give some food for thought and makes one wary about what one is trying to accomplish with a framework.
You said: “It makes me cringe.
And yet, for some reason, everyone I talk to just RAAAAVES about Spring. I don’t get it. ”
Maybe the reason is that the frameworks actually works for them?
The organisation I work for has about 500 programmers - all working on a single integrated application. Millions of lines of code. Two hundred thousand software modules of which 20% need to be revised each year because of changing business requirements (government legislation!). A mistake in any module can, potentially, stop the whole application - the cost of which is about $1,000,000 per hour because 30,000 employees cannot do their job.
How does one TRUST all these programmers (and associated business analysts, database designers, etc) not to make mistakes?
Well, you can’t. Instead, you need to set things up so as to minimise the likelyhood of mistakes, and their impact. These is where frameworks come in.
You also said:
“A library is something *contained* within my code.
A framework is a *container* for my application.”
Absolutely right. Because the framework is actually driving the application it can ensure that certain things happen exactly when they are supposed to happen. You can’t trust programmers to ensure they lock database records correctly, or commit transactions at the right time, or they access a database only a particular way, or provide a consistent interface across the thousands of screens or web pages - so instead you remove the need for the programmers to worry about these things by either preventing them from doing these things, or you give them only one way that works.
It is easier to do this with a framework than with any other way I’ve seen.
In a sense the framework represents the overall design of the application - generally a good framework handles the non-business “glue” functions, and the programmers only worry about the business code. Of course the world is not perfect and this separation is not so neat - but overall most things ARE separated, and a few very complex things remain - and they are the ones that rightly receive the most scrutiny (eg tuning for performance).
One needs to examine the framework and decide that it is appropriate for the application. If it is appropriate, and the framework is good, then it should provide enormous benefits. I am not familiar with Spring, but the support for it is evidence that there are classes of applications for which it must be very suitable.
Why do you think SAP is very popular?
September 6th, 2007 at 7:00 pm
My post is actually referring to an old very humorous article, and subsequent comments, now archived here:
http://discuss.joelonsoftware.com/default.asp?joel.3.219431.12
Cheers
September 7th, 2007 at 1:11 pm
Luciano says:
“The organisation I work for has about 500 programmers - all working on a single integrated application. Millions of lines of code. Two hundred thousand software modules of which 20% need to be revised each year because of changing business requirements (government legislation!). A mistake in any module can, potentially, stop the whole application - the cost of which is about $1,000,000 per hour because 30,000 employees cannot do their job.”
Luciano, in your case, I’d suggest that the application is just too damn big. There’s nothing anyone can do, with any framework, to make a software project of that size comprehensible to the people who work on it.
Without knowing more about what the application does or how it works, I can’t make any kind of definitive commentary, but I’d suggest that the application should probably be broken into a smaller set of independent applications, sharing some small core codebase.
I also can’t really comment on the applicability of IoC frameworks for huge applications like this. I’ve worked on plenty of applications with a million or more lines of code (and in every case, where IoC and ORM frameworks were used, I’ve thought it ended up being a total train wreck), but I haven’t worked on anything that’s quite at the scale you’re implying.
Anyhoo…
I’ve been meaning to write a more detailed essay lately, about the taxonomy of software packaging (platforms, frameworks, libraries, etc), where I clarify some of my terminology and make a more rigorous case against frameworks. But I haven’t gotten around to it yet because I’m busy playing with puzzles.
June 18th, 2008 at 1:21 pm
Very funny indeed, but I think you might be better off using annotations because xml is evil!
@RunOnServerWith(”")
@UsingDatabase(”inlined conection settings”)
@SecuredWith(YourFavoriteSecurityFramework.class)//ah shit, I would need an import for that..
…
@DomainEntity(type=”…”)
@DomainEntity(type=”…”)
@
@
class MyApplication {
}
On a more serious note, I don’t think frameworks in general are evil, you just need to use them on a ‘need to use’ basis. When you need a good framework for date and time you use Joda time, when you need something to work with quantities and units you use jscience. Writing everything yourself is just plainly stupid in most cases. If I wanted to do that I’d be programming in Smalltalk. In fact the current Java framework landscape would make you a fool if you ever worked with a socket or started your own thread (in most cases).