More Ramblings from a Los Angeles Programmer

July 5, 2007

What frameworks do you use?

Filed under: coding — Josh DeWald @ 11:50 am

Just kidding, I don’t really care. I’ve been wanting to write on this topic for a bit but haven’t been able to figure out how to go about it. In some ways, I probably don’t need to, because there so many absolutely stunningly written blogs out there that can convey the things I want.

I recently saw this entry via reddit which made me go “Eureka!” because it conveys so well the ideas being my posing of the question: “What’s the problem you’re solving, and what’s the algorithm you’re using to do it?” rather than “What framework are you using to solve your problem?”

In it Reginald Braithwaite discusses the idea of certifications and what his certification would test. Most importantly is the idea that it wouldn’t test any specific frameworks, languages, methodologies or tools. Almost as importantly, he says that he wouldn’t be able to pass it without studying. A lot.

His certification would test your knowledge of and ability to… test. This is such an amazing concept because what it really means is that it tests your ability to actually understand what you’re building. Sure, you can make sure that when you click a button that a screen is displayed. But:

* What’s supposed to be on that screen? (And how do you know?)
* What did a user do before clicking on that button?
* Why does the user care what’s on that screen?
* What happened between pressing the button and displaying the screen?

The last question is the most important: you can just have a static “Web 0.5” static HTML site if pressing a button just results in a static screen being rendered without processing occurring.

Being able to design for testing means that you can state, at the beginning that: “Given a set of inputs I with values (A,B,C,…) the end result will be R“. And then you can verify that this is true before you write the code that does it. Using this as a black box, someone on the outside doesn’t have to care how it gets done but merely that it does get done. A non-programmer can use the statement and understand what is supposed to happen, but they don’t have to care how. What they can do is say “Hey, wait a second! When I enter (A,B,C) I actually want R2 to happen!”. This is a powerful notion indeed.

So many of the problems with our (and I include my own here) systems is that they aren’t actually tested or even, more frighteningly, testable. We just hacking on it until it appears to do what we think it might need to be doing. “Yeah, that looks right.” Meanwhile, every time that button is pressed data is being recalculated (what algorithm? why?), a database is being pulled (how do you know the query is correct?), servers are being connected to (securely? what protocol?) and a screen is being rendered (sure you didn’t miss any of the returned data?).

The actual framework you’re using for all this doesn’t matter. Sure, it might help you do it because it makes it easier to quickly generate the application. But that doesn’t make the code correct at all. Even a little bit.

Just because it looks pretty doesn’t mean that it’s actually solving the problem.

Anyhow, please read Reginald’s blog (I’ve just recently subscribed to it, it has a lot of good stuff) and other people’s. Subscribe to my ‘starred’ items which are articles that I think are particularly good (not always about programming). There’s also my ‘programming’ feed which are all the blogs I subscribe to related to software engineering/programming (warning: it includes reddit as well, which tends to have about 50 entries a day). Yes, I group programming and software engineering together because one can’t be done without the other and I don’t want to argue about the differences right now.

Note that I can’t tell whether or not you subscribe to either of these.

Lastly, don’t just go and take my word on anything I say. These are just my opinions, which I’m forming and re-forming all the time as I design, interact and fix systems on a day-to-day basis.

Note: I would consider a programming language just another framework.

Update: Realized that I said “we” instead of “he” when talking about not passing the certification test, which I think is a big distinction.



  1. here is a nice blog from benji smith, one of my favorite blog article

    Comment by Dilip — July 6, 2007 @ 7:09 am

  2. Bet he knew exactly how and why he’d have used the hammer, if only he could have gotten one!

    Comment by Josh DeWald — July 6, 2007 @ 7:51 am

  3. Typo:
    I think you meant “want” not “what” in:
    “What they can do is say β€œHey, wait a second! When I enter (A,B,C) I actually what R2 to happen!””

    BTW, intersting post, though I think there IS a distinction between frameworks and languages. You can build language agnostic frameworks and framework agnostic languages, but there seems to be a distinction there. Perhaps frameworks (and algorithms) are *what* your app is doing, and the language is *how* it gets it done? That might not be quite the right distinction, but if “I know it when I see it” (and I think I do) I must be differentiating on _something_.

    Another way of looking at it, is that the language is the potential, and the frameworks/programs/algorithms are the realization. Java doesn’t run my website. Code in java (including frameworks, and my own algorithms) run the site.

    Hope this didn’t distract too much from your main point.

    Comment by Harry — July 6, 2007 @ 9:34 am

  4. Will fix the typo there.

    I agree in general that a language is not a framework… but it is in the sense that I don’t think the accuracy of what you build is related too much to the language you choose. In practical terms, some languages might make some parts of the problem easier… but I don’t think a business will succeed or fail based on their frameworks/language choice.

    But if I do take my point to the extreme (and another friend used this against me in jest), then Java (or any other high level language) is just a abstraction/framework that makes you not have to worry about Assembly. It provides useful constructs that extends a near “jump if zero” to allow you do to complex logic expressions for branching.

    Comment by Josh DeWald — July 6, 2007 @ 9:48 am

  5. Framework selection does matter. Framework solve problems. A framework could be chosen that doesn’t solve any problems, but then one has chosen the wrong framework. Not all projects require a framework. As with any solution, an effective engineer chooses the right tools for the job. I repete, frameworks matter.

    Comment by Kenneth Riggio — July 9, 2007 @ 12:26 am

  6. Ken –
    Of course the framework (JSF vs Struts, C++ vs Java, Hibernate, …) matters for the system as a whole as it’s developed and maintained. I don’t mean to say that these hold no relevance. But for me, they have no bearing on the accuracy of the data and logic designs that create the “secret sauce” that actually solves the problem or creates an innovative experience. They create an easier “container” for the real meat to live in, so that the core developers don’t have to focus on the scaffolding.

    And as you point out, a badly chosen framework could actually make it harder for someone, but that should only mean that, say, redeploying it against another database is more difficult than it should be. It shouldn’t affect the core logic of the system.

    In any case, my preference is that I’m not anywhere near those decisions… there are people much more qualified than I am to make those framework decisions. I would much rather focus on the overall design of the system and assist with the core implementation. Others hopefully have expertise in the knowledge that Spring is great at certain types of scaffolding problems, and Hibernate at others.

    If it turns out that the entire application is merely a linking together of various frameworks, so be it, a lot of time and money is saved. But that type of project isn’t the focus of this entry or of real interest to me. What *would* be of interest in that case is good analysis that went into realizing that no real logic would have to be written, but rather it was a fairly mechanized wiring together of frameworks.

    An uninteresting application no doubt πŸ™‚

    Comment by Josh DeWald — July 9, 2007 @ 9:01 am

  7. […] the requirements given to me. I actually do not tend to be up on the latest trends in WS-* or frameworks, etc so most of my code is pretty straightforward (I hope). Thankfully others I work with (both at […]

    Pingback by Architecture and Coding « More Ramblings from a Los Angeles Programmer — November 27, 2007 @ 8:49 pm

RSS feed for comments on this post. TrackBack URI

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Blog at

%d bloggers like this: