Research and Destroy

Did you ever get scared about modern Software being all too intelligent, that it would finally take control and such? Don’t be.

At our office in Cologne, there is no staff canteen. So we either have to eat out, or go the the super market next door and cook something for yourself. There are also to internal mailing lists, where people can organize lunch together, and the most popular one is the “salad group”. One person acts as so-called “salad manager”, which suggests a menu and organizes everything, one or two persons go shopping to obtain all ingredients, and everybody who wants to helps cooking.

Once in a while few of us R&D guys join them, but we prefer something more meaty for lunch.

Having been to Klagenfurt one day last week, Sven and I had our own version of the salad group for supper there: Spare ribs salad with chicken wings, meat slices and corn as side order!

Having found a blog entry at Simple Thoughts (granted, without source), that Steve Ballmer admits Windows Vista is a work in progress. Well, who would have thought.In the same context I stumbled over the following manual, created by a power user, how to correctly install Vindows Vista on a box. And what a box preferable to use. See for yourself: 

Having not used MS Windows for a long time at home, except maybe for gaming, which I don’t do really often these days, I don’t know pretty much about the tricks and tweaks of this really pretty operating system since version 2000. Finally at my job here I’m forced to use it again, despite there is absolutely no reason for it, as nobody uses office documents anyway. All the documentation stuff is kept in our confluence wiki and nowadays Lotus Notes works pretty well on Linux.But now, being assimilated, I had to work with what I have. So let’s see how it’s going.

Sloppy Focus

Besides a proper shell interface the most important thing I miss in Windows is a working sloppy focus. I just love it! Someone, I don’t know who, told me there might be some sloppy focus utility in these PowerToys, but they pop the windows selected on top of the stack after a timeout, so I’m hardly gonna like it. So, unfortunately, I had to go somewhere else and found a pretty good working sloppy focus utility named True X-Mouse gizmo which not only offers a sloppy focus as on all *nix/Linux desktops, but also the nice “copy-on-select/paste-on-middle-mouse-button” feature what would have been the next on the list. The licensing terms are funny though:

Usage is free, but only those who have sent a postcard(*) are entitled for support:-) Postcards with a view over your home-town or other local sight signed with encouraging words and your E-mail address are to be sent to<snip>name and address of the author</snip>(*) Employees of Chalmers University of Technology don’t have to send a postcard.    

Multiple Desktops

Having used several of these utilities at the beginning of my former job some six years ago, when I had not switched to Linux there, I tried out the first three I found and ended up with VirtuaWin. It offers a pretty customizable interface so you can hook up the screen switch onto the keys you’re used from your favorite operating system, or you may click on the tray icon next to the clock. It’s even pluggable so you can add features like the cool desktop name which fades out you might know from WindowMaker.Licensing is GPLv2.

Shell/Terminal

 As mentioned above there also is no proper terminal on Windows. Sure, there’s this “cmd.exe” or whatever it’s called these days, but It doesn’t work for me: rudimentary tab completion, slow rendering of outputs, and this ugly windows command syntax. So the next logical step is to get Cygwin for Windows, which by default offers a ported native bash environment inside such a “cmd” terminal. This leaves the ugly handling of this window, including cranky buffer configuration, resize issues and the IMO very slow renderning of text output, e.g. when tailing a logfile which writes hundreds of lines in just a view seconds. How nice a simple xterm  would be…So just install it. Cygwin offers you to install a X server, namely XFree86, out of the box. The only issue here is it’s not pretty straight-forward to configure, I had a hard time to get it up and running as such, as the Cygwin guys have done lot’s of customizing here.Maybe take a look at the X live cd, they package the Cygwin X environment onto an autorun-cd for Windows: push in, click “start x” and you have a full-fledged X server running on windows with native xterm and all the basic utilities you need (at least I need) in my day-to-day work. It also offers an “install to hard drive” option, but this doesn’t work pretty well either. Unfortunately I haven’t taken notes for a walk-through, maybe in the future…WHEN you have it, finally, up and running, you basically have two options how to configure your X-Server: 

1.  Start the X server as a “window” with a window manager of your choice (blackbox included).
2. Start the X server with a special window manager which integrates your X windows into the windows environment, so all X windows are just decorated as usual Windows windows and integrated into your desktop seamlessly.

I decided for the latter option, for the sake to only have one environment, even if I don’t like it. Works pretty neat, having finally a xterm running screen running nice utilities I never wanna miss like tail, grep, ssh or find. OK, it’s not perfect, but hey, it’s usable… 

Really… after all that architecture nonsense and fruitless “platform” development (like in “fill the svn with a crapload of thingies which are ignored and reimplemented anyway”), the old question: “Yeah! But is it ART???”. How could web application development possibly benefit froum our efforts?

Today, I came across my first new component that did, for a change, require no big deal of “platform” implementation. In the unyielding hope, that this at one far day might become the rule and not the exception, I’d like to shed some light on the details.

• I started with the query. That is a good way to start, one gets a good hold on what to expect and what to pay for. Since we are doing a rewrite of existing software, I held my breath and dove deep into the existing PHP. To find a previous implementation in the action code that pretty much resembled a query along with some decision code and a “routine” (Piece of code set apart with blank lines and actually sporting a comment) to determine bar width for some kind of bar diagram – fine.
• The query wasn’t too complicated, basically a PageableListQuery, for which a base implementation exists. In my concrete query, I put in interfaces for Cacheability and the data provider datasource where it should be executed.
• Once the query was there and I had determined the query parameters needed, I realized that the return type of that query actually missed in our Object model. Since our BOs do not have any Dependencies, I unscroupulously added a new class asking questions later.
• The class stayed small, the table actually looks full of data but in reality it only has a few colums plus it is sortable.
• Suppressing the urge to do something entirely different first, I introduced a pretty stark junit test case that asserts at least the query string that goes to our data provider and checks if it is possible to get a result at all. Of course, the result list had zero elements and some Exception hit the wall next to my head.
• There was a new BO Type, so I had to write a Mapping for it. Since I am the first and only person to request this BO type, my Mapping goes to the class annotation as default mapping, go me! And since it is an unspectacular list mapping, I even get to retain the GenericListMapping for the iteration part and only have to implement the single object part, which is nice because this is very unlikely to produce strange errors. Mappings could be far more generic and self-contained, but our data provider has a rather odd object design and it is better understandeable to have some repeated code than some cryptic extension code to a generic mapping where no one knows how it works.
• With the generic list mapping annotated to the query class and the item mapping to the BOM class, the platform knows enough to get me datah! One day soon I’ll make GenericListMapping default for all ListQueries, but that’s not so easy.
• Tried the test case again. Yay! One field was not mapped correctly, but the result graph was o.k. It is good to know that a query executes correctly without having to deploy the application to JBoss to find out.
• Added some meat to the test case, but it is not wise to make the data content tests too sharp, it is not our Job to ensure data quality of our data provider which more often than enough irritates our tests. A result list with more than one entry and the first entry object with some correctly mapped fields in all graph objects was enough.
• Started Struts action implementation. Since the table does not have any complicated decision code and no data rearrangement voodoo either, I didn’t have to add much to the class. There is a default implementation for actions that display a List of BOs called PageableListAction which I could extend, all I had to do is add the action parameters, a method that creates the query and passes the action parameters to it (if that does not come from the configuration) and a little method to calculate the bar width. Since this one does not produce an array of widths but only one result per BO, it shrank down to one line.
• When looking into the navigation.xml config I saw that The Ralph of God had already left His traces. Normally, I would have to add a menu point in the main Navigation and four tab navigation entries there, pwith the possibility to configure default parameters or query implementation.
• in the struts.xml, someone had done similar, but I still had to add result entries since the JSP (can’t blame them, the pages don’t exist yet, not everyone is adept at precognitive software engineering) since we do no magick in the struts config, I can forget about that file from now on. Actually, I do so from time to time, the PostIt at my monitor labeled “Remember that there is a struts.xml” surely helps.
• Speaking of JSPs, they were the worst part that time. Usually, there is a premade file from the HTML Ubergurus which dwell on the surface that I can cut and paste, put some <xx:iterator> and <xx:text> here and there and be done with it, but these were a little strained with other, more important stuff so we had to extract from the old system. Which is what I did, the templates of the old system are well separated from the “action” code (that is a good thing) and it looked easy enough.
• There are 2 JSPs now, one for the page and one for the component. It is the first and presumably only usage of that component, but concrete implementations of entire pages always attract later changes that fry the recyclability. The component jsp is called from the page JSP by <xx:action> and that’s it, since I do not require any additional parameters yet that I would otherwise put in here.
• Added standard component JSPs for taglib include, header and footer to the page and and tab navigation along with a page count/progression control to the component JSP, whatever crash should occur on that page, it will at least look nice from now on.
• There should be a test case for that one-line bar-width calc method, I know. I promise, there will be some time in the future.
• Smoke test. Bäm. Some THING emerged. From now on, bugfixing.

When you build a web application using maven2, there are funny log messages in the output, if you care see them:

[INFO] [war:war]
[INFO] Packaging webapp
[INFO] Assembling webapp[commodities.view] in [C:\code\commodities.view\target\commodities.view-0.1-SNAPSHOT]
[INFO] Processing war project

Whom is this maven thingy going to attack???

© derlanders

If you’re not familiar with FAD, then you’ve been missing out. Essentially, FAD is a fundamental paradigm shift over the “traditional” and “neo” ways of building software. Not only does it surpass every other software development methodology out there, it solves every problem there is to building software. And then some.

The FAD Manifesto

I. Front Ahead Design
The essence of FAD is conveyed directly in its name: design your front-end/user-interface first, ahead of everything else. The customer could care less what’s behind the scenes, so long as it looks good and does what it’s supposed to. Deliver a working front-end first and then Do What It Takes to fill in the functionality gaps.

II. Do What It Takes
Other methodologies are great at delivering excuses. How many times have you heard (or have been told) “we can’t do that here because it could throw off the whole design?” In FAD, you just do it (that would have been the bullet point, but Nike has it trademarked). To get it done, you Do What It Takes. Your customer will love you.

III. Code Light, Not “Right”
A traditional methodology calls a complex framework with layer after layer of objects. In those ways, adding a simple value to a form can be a monumental task, requiring it to be added to every single layer. Does that sound right? Proponents of the other methodologies will tell you it is, but what about your customer? With FAD, you just Do What It Takes to add the functionality to your interface. No more.

IV. “Throw Away” Diagrams
Think of all the Visio diagrams you’ve drawn over the years. Sequence diagrams, context diagrams, flow charts, and so on. Was that really productive? Did your customer ever see any of those? Were those diagrams even relevant after the system was finally developed? Didn’t think so.

In FAD, all diagrams are made on a disposable medium. Whiteboards, napkins, even your forearms work. And there is no formal modeling language to battle with: just Do What It Takes to draw and explain your design to other developers.

V. Life Is Short (a.k.a. Patchwork)
The average software system has a life expectancy of seven years. No matter how “properly” the system is designed from the start, within the first year of its life, maintenance programmers unfamiliar with the complex architecture (and having no help from out-of-date documentation) will turn the system into a complete mess with bug fixes and change requests.

In FAD, this isn’t even a concern. We know the short life span of a system and develop every feature (from the interface) as a patch. Maintenance programmers can come in and Do What It Takes to add their patches. In FAD, we don’t even try to stop the aging process. We encourage it.

VI. Learn To Deal
Many other methodologies focus on delivering “quality” (as in “bug free”) software. And guess what: they fail. Miserably. No matter how hard you try, software will have bugs. In FAD, we just learn to deal with it, and we encourage the client to do the same. So what if the application crashes when you click that button that way? Don’t click the button that way, and learn to deal!

VII. Be Environmentally Conservative
In the real world, there’s only one environment: it’s called The Real World. So why do some methodologies invent these counter-intuitive, bizarro environments called “QA” and “UAT”? Do architecture firms construct an entire house before building an addition on yours, just so they can “test” their building skills? Of course not, and neither should software developers. In FAD, there’s only one software environment: Production. Anything else is pollution.

FAD Application Design

NOTE: First and foremost, understand that the FADAD is merely the preferred method of building applications. Because in FAD, we do what it takes, a lesser or more in depth approach can be used as needed.

Many of the tenets of Front Ahead Design are based on the failings of other methodologies. FADAD is no different, and draws some of its key facets from the archaic Model-View-Controller architecture. In MVC, there are three different components: the Model (the data), the View (the UI), and the Control (everything else).

If you think about it, two of MVC’s components are nothing but dead weight. All anyone – including the client – really cares about when all things are said and done is the View. Therefore, in FADAD, our guiding architecture model is simply called “V”:

The H/YPE Framework: The FAD Developer’s Best Friend

If there’s one thing that’s frustrated just about every developer out there, it’s “untouchable” library code that almost does what you need it to, but not quite. For FAD developers who chose to use the H/YPE framework, this is not a problem.

Unlike the stodgy libraries of yesteryear, H/YPE is not a “compiled” library. It’s a set of cross-language codefiles that can be copied to any application, and is designed to “live” with that application for life. Don’t like that 48 plus 92 is not 4892? No problem! Just edit MathHelper. Here’s a small subset of what comes in H/YPE:

• HYPE.StringHelper – all sorts of functions like IsEqual, AreEqual, Add, Subtract, Join, DoubleJoin, Encrypt, and Decrypt
• HYPE.VHelper.HTML – the ultimate HTML library including functions like WrapInCENTER, UnHTML, ToHTML, and ScriptBlock
• HYPE.Audio – everything you’d ever want to add audio, including Beep and BeepMore

But Wait, There’s More: Certification!

No, I don’t mean to sound like our good friend Ron Popeil, but before wrapping things up here, I wanted to tell you about the latest excitement in the world of Front-Ahead Design: certification!

Just last week at the International FAD Conference in Azerbaijan, I joined several other FAD leaders to formally announce the first official Front-Ahead Design certification program: the Fadstronaut certificate. Why Fadstronaut? Because we felt that the astronaut was the best analogy for the challenges and difficulties that FAD software developers face each day.

Becoming a Certified Fadstronaut is easy, but not too easy. All you need is one year (1,000 hours) of verifiable FAD development experience, and you’ll be eligible to sit for the Fadstronaut certification exam. Score in the 50th percentile, and you’ve earned the designation Certified Fadstronaut!

I hope that gives you all a good idea of what FAD is all about. Believe me, there’s a whole world more of FAD out there. That said, I hope to see some of you soon at the Worldwide FAD Meeting in Buenos Aires next month!

http://thedailywtf.com/Articles/FrontAhead-Design.aspx