Naturally the real solution is getting the build to run in seconds… Technical debt, thou art a harsh mistress.

Replace the last couple of lines (starting with ‘exec’) in your mvn script with:

"$JAVACMD"
  $MAVEN_OPTS
  -classpath "${M2_HOME}"/boot/classworlds-*.jar
  "-Dclassworlds.conf=${M2_HOME}/bin/m2.conf"
  "-Dmaven.home=${M2_HOME}"
  ${CLASSWORLDS_LAUNCHER} $QUOTED_ARGS && say "Success!" || (say "Failed!" && false)

Updated: Changed to avoid incorrectly returning a successful exit code on failure.

Bookmark to:

As Luis Abreu points out, I don’t think there is a precise definition of what DDD actually is but for me the essence of DDD is still the same as when I compared it with OO i.e. Domain Driven Design = Object Oriented Programming + Ubiquitous Language.

I think that Mark is on to a very useful and succinct definition of DDD, yet I feel he overlooked the Law of Demeter. Building on Mark’s definition I’d define DDD as Domain Driven Design = Object Oriented Programming + Ubiquitous Language + The Law of Demeter. While some would argue that the Law of Demeter is implicit in Object Oriented Programming (or at least of OOP of the good kind…) I believe that it is important enough for successful Domain Driven Design that it should be explicitly mentioned.

Looking forward to your comments!

Bookmark to:

You are in charge of a project for developing an internal application at a large brick-and-mortar company. Your target audience for the application are the employees of a critical business department (here on, Department X). The customer representative is the head of that department and is glad to be involved in the planning process and domain knowledge sharing as well as story analysis, hand over and sign-off; Seemingly, an ideal ‘customer’, here on- Mr. X.

Yet at scope planning meetings for the project, Mr X. is insisting that all the feature requirements are ‘Must Haves’ and while he agrees that the order of development should be based on ‘higher business value first’, he refuses to de-scope any features, insisting that due to external circumstances their delivery must occur by the project’s go-live date.

You would accept Mr X’s proposal if he would be willing to increase the budget for project to allow resourcing to meet these requirements. Great! He is willing! But wait — he can’t. Why? Because the project is funded out of the IT budget and not out of department X’s. This is a lose-lose situation, as the project is now set to fail in the eyes of the customer and in turn, harming the IT department’s reputation – Department X is not getting what it wants, even though it is willing to pay for it. 

The root cause here is the divergence between the beneficiary of the application and the entity that pays for it. The two may have differing goals, priorities, political considerations and machinations and whilst they both work towards the same organisational goals, these two entities operate under different business units with sometimes divergent operating considerations.

Budgeting models for IT departments seem to be based around IT as infrastructure — which makes sense for, wait for it… infrastructure: network, VOIP, hardware and the like — but repeatedly fails for business applications.

While it makes sense for IT departments to harbour the core capabilities and knowledge for software development (….development infrastructure…) it should only act as a cost-effective contractor to the business when developing business applications. Business applications projects should only be undertaken as part of a business case, they should have clear ownership by the benefiting entity and not the IT department.

When analysing teams and projects that clearly ’smell’ and have a hard time changing, my personal experience indicates that in the majority of cases, following the smell to its source leads to this root cause. This is more pronounced in bigger organisations and seems to be proportional to the level of organisational separation between the project beneficiaries and the IT department. More so — this is almost always the underlying organisational issue that makes it difficult to implement agile methodologies.

This lesson was learned by many organisations, but unfortunately not all — and it should–

 The ‘IT department pays’ model of application development should die.

Bookmark to:

Selenium has a Firefox extension that acts as an IDE for recording and editing test cases however there is a significant difference between running the tests in the IDE and running them as part of a build process — cross-site scripting.

When running tests in the IDE, Selenium is not limited by Firefox cross-site scripting preventative measures and can follow links to external sites (outside your ‘base URL’) and verify that the target has been reached. This is not possible when running it as part of a build process in stand-alone mode.

The reason for this difference is that when running Selenium in stand-alone mode it generates a web-page that contains the test runtime with the actual web-page it is testing residing within an IFRAME. Once you traverse to links outside the domain the Selenium generated web-page is at (usually localhost) then you are subject to cross-site scripting limitations. Put it simply, your top page (Selenium generated) would be in the ‘localhost’ domain, and the external page is at another domain thus triggering the cross-site scripting security restrictions.

I’ll demonstrate what I mean:

In Selenium, a typical link test is done so:

1. A ‘click’ Selenium command with the ‘link=’ target.
2. Then a ‘waitForPageToLoad’ command
3. Followed by an ‘assertLocation’ with the correct expected URL

This test will fail when running in the standalone mode with the link target being external to the domain running the Selenium web-page. Instead of what you expect from the IDE based run you will hit upon permission errors accessing “document.href” and other DOM properties. This is simply because your script is from domain “localhost” (for example) and does not have access to the DOM of the page from the external domain (say “rationalistic.com”)… Note that for the same reason you can’t even call ‘goBack’ after the ‘click’.

An alternative to this method that is useful for external links is simply to verify the existence and ‘href’ attribute of the link. While this is not ideal (as it doesn’t take into account Javascript method links) it is, in my opinion enough verification for off-site links. To use this method of testing a link’s existence and target you must give the <a> element an id, preferably one that starts with “link_” and then using the Selenium ‘assertElementPresent’ and ‘assertAttribute’ commands.

For example, consider a link to my blog site:

<a id=”link_rationalistic” href=”http://www.rationalistic.com”>The Rationalist Manifesto</a>

To test it in Selenium you would do this:

1. Use the ‘assertElementPresent’ command with a target of ‘link_rationalistic’
2. Follow with an ‘assertAttribute’ command with a target of ‘link_rationalistic@href’ and a value of ‘http://www.rationalistic.com’.

This testing method provides reasonable confidence that the link exists and leads to the correct location without following it.

Note:
This method is also useful for links which have symbol characters in them which may be difficult to locate using the ‘link=’ targets.

Bookmark to:

I agree with Rentzsch completely on this point, however I do believe that Rosenberg, having come from the wrong direction, has hit a point with “Rosenberg’s Law”:
“if you are doing something that has already been done — then you have a frame of reference to estimate how long it is going to take, and to guess how many people are going to be required”

I’d like to rephrase this in Rentzsch’s “problem solving” terms, and paraphrase “Rosenberg’s Law” as:

“A relationship between the unfamiliarity of a problem to the difficulty of estimating the required resources to solve it.”

Which is not surprising in hindsight, as it is a relationship between one type of uncertainty to another…

Bookmark to:

The session restore feature was hard to find because I was looking for the phrase ‘Session Restore’ in the preferences. However, in FF 2.0 you simply have to set the “When Firefox Starts” combo-box to “Show my windows and tabs from last time”.

Small suggestion: Upon first install pop-up the usual ‘You’re about to close all tabs’ dialog box when the user exits, with a check box that says: ‘Restore my tabs next time I launch Firefox’.

Also, I like the per-tab close buttons that are similar to having the Tab Mix Plus extension installed on top of Firefox 1.5.x, however I miss the ‘Close Current Tab’ button at the fixed position on the right hand side as it made it very easy to ‘muscle-memorize’ the location. Now I have to think (god forbid) to close the current tab, especially to make sure I don’t accidentally close another tab. Additionally, I miss the close-tab button on the tabs that are not in focus.

Technorati tags: mozilla, firefox, usability

Bookmark to:

Most if not all designers would agree that it is less effective to tweak a widget’s design on its own without the ability to easily gauge how the change will affect the overall look. However this is exactly what the ‘resource approach’ requires, as each design element has to be in a different file and it is only after an export, compile and run cycle that you see how it all fits together.

This is less than optimal, so you would typically follow a different flow.

To enable you to see how the design elements interact without requiring an export, you would arrange a design mockup within Photoshop with each design element as a layer (and/or sub-layers in later versions) and perform all the design work right there. This is what every graphic designer does and theoretically it is then just a matter of exporting the layers (and sublayers) to files.

Good so far, but usually this is where the trouble starts — as many times the export process involves a lot of tiny elements which all require export to different files. Usually this is done outside the build process by a 3rd party graphic artist who sends you the exported files by eMail and sometimes forgets to export one or more of the elements. Only when this is finally settled, does the result gets tested within the build… And… Guess what, there’s a problem.

*Sigh*

It was to make my life easier and to enable the graphics design to be a full (and honored!) member of the automated build cycle, that I automated this export process.

Ages ago, before Photoshop scripting I wrote a small utility called PSD Ripper that simply parsed the Photoshop 6 .PSD file and converted individual layers into individual PNG files, it also used the layer name as the basis for the PNG filename. Later versions of Photoshop made it much easier — to achieve the same result I merely had to make a tiny modification to a small script that came with Photoshop.

However, as great as Photoshop is, lately I have come to appreciate a vector-oriented approach to design and have been using Adobe Illustrator to do the design work. Therefore, I needed a script that would enable me to continue with the same workflow except with Illustrator instead of Photoshop and as none was available, I wrote one.

Thus I present “Recursive Exporter for Adobe Illustrator v1.0“, tested with Adobe Illustrator CS2 12.0.

The lay of it:

Recursive Exporter for Adobe Illustrator v1.0 (2006)

What it does?
Recursively export layers and groups from Adobe Illustrator to 24-bit PNG (with alpha/transparency) support. Does smart naming of files and the level of recursion can be limited.

Usage:
The usage is pretty simple, once you run the script it will ask you to which folder to output the results and how deep it should recurse beyond the top layers. It will then output each visible non-locked element as a 24-bit PNG anti-aliased, alpha-transparency enabled file. Then the script will recurse into the element (if it is a layer or group) and do the same for each of its components.

The name for the output file is constructed recursively, so if you have a ‘logo’ group within a ‘banner’ layer it will export the group as ‘banner-logo.png’. Note that Illustrator enforces a 31-character filename limit.

If you want to create a background matte layer that will be included in every element simply add a visible, locked layer. It will not be exported on its own but will be visible when the elements are exported and thus included in them.

Problems:
Please report any bugs or problems with this script to the comments section.

License:
The script is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 2.5 License and is made available with absolutely no warranty or guarantee.
Technorati tags: photoshop, illustrator, Adobe, design, scripting, Javascript

Bookmark to:

Actually, he misses one of the main reasons the C&C pattern doesn’t even work for the military.

It all begins with the 1973 (no, seriously) Yom Kipur War between Israel, Egypt and Syria. Having taken Israel by surprise, the Syrian tank divisions storm through the Golan Heights and almost reach Nafah where the headquarters for the Israeli forces were located.

Had the Syrian forces reached Nafah, they would have most likely defeated Israel and conquered the Golan Heights at the very least. But they haven’t, and didn’t — instead, they stopped.

Just before overtaking Nafah (‘on Nafah’s fences’ as Wikipedia describes it), the Syrians halted their advance. This allowed time for Israeli reserve forces to arrive en-mass and overturn the tides of war, eventually costing the Syrians their victory. To this day, no one outside Syria (and maybe Israeli Intelligence) knows for certain why the Syrian force stopped so abruptly.

There is a prevailing theory, however. This theory boils down to the difference in management style between Arab armies (Soviet trained) and the IDF. Arab armies are trained for complete Command and Control management, an underling will not make a move without being issued a command. The most initiative he can show is to suggest a course of action to his superior, who might suggest it to his and so forth until the highest authority on the matter is reached, once he makes a decision the order to action travels down the chain of command. As any software engineer will tell you, this upstream-downstream transaction means very high latency.

Israeli military on the other hand, have an altogether different standing order: a soldier without immediate contact to his supervisor is his own chief-of-staff. This translates to initiative and rapid response during the fog of war.

So imagine that the Syrian tank brigade commander, having surpassed his superiors’ expectations and advanced so quickly into Israeli held territory that he exhausted his current orders. He was not meant to reach Nafah so quickly! As he is trained not to question his orders, and as he is only given very limited information (on a supposed ‘need to know basis’) he can’t assume that proceeding forward would fit with the larger plan.

Thus our well trained commander jubilantly radios back his headquarters and informs them of his brilliant success and requests further instructions. While his report travels up the command vine, he and his forces are minutes away from victory and are standing completely still.

The next step of the reasoning is quite clear:

Use a command and control management style and you will be the bottleneck of every development step, as every decision beyond what to call the class file will be relegated to you. This is not just hit-and-run micromanagement, this is a semaphore locked development cycle and is hardly an efficient use of your very valuable resources (otherwise known as: people).

While there are many (many!) number of arguments why C&C does NOT work for software development projects (for example: writing good software is a creative process, C&C management hampers creativity) I think the above is the most important and most direct argument against such a style of management.

Having said that, there are places where C&C is just fine.

Technorati tags: software-development, management

Bookmark to:

It is not unlike the early Java-rush years in which every tiny in-house web-application seemed to some misguided souls like a nail aching for the punch of the overweight EJB hammer.

Rails development scales very well, so if you are developing a web-site, you’re in for a pleasant surprise using it. Whether you develop alone or with many team members, whether you deploy for ten concurrent users or ten-thousand, Rails is definitely the right tool for the job. But if you are developing something more state heavy, such as a web-application, then you are in for a nasty headache when your code goes O(spaghetti^2).

Rails is a great tool for what it does, but when you’re writing software that translates to a different architecture than a thin-state web-site (as rich an experience as it may be!) using Rails will be like trying to fit a square peg into a round hole (when the cliche fits…)

Web site/app, what’s the difference?
The difference between the two boils down to the number and complexity of the states of the software… …Huh?

Let us demonstrate: A good example for a web-site is IMDb, it aggregates information about movies from various sources including other users. Another example for a web-site is OkCupid.com which allow online matchmaking and interactions between users. Contrast this with a web-application such as Google Spreadsheets which is pretty much a hosted version of Excel + collaboration. Another example for a web-application (although one that is smaller in scale) is an application which allows you to control your home automation remotely via a web browser.

What is a web site?
A classic web-site is a thin view layer unto an expansive schema which is modeled and stored in a database. The use-cases it implements are shallow on their own right but their aggregate creates an experience which is much larger than the sum of its flows.

The main draw of a web-site are the users– you are not interacting with the software alone, you are part of a grander ‘community’ (as much as this word brings a bitter taste to my mouth at times)– While using a web-site you become part of the network and as a user you give value back to the site by interacting. This is the ‘Web 2.0′ vision, a painful buzzword on its own.

Web 2.0-type sites are absolutely ideal candidates for Ruby on Rails and as such there are many success stories to be observed. I’ll skip the bother of listing them, go to RubyOnRails.org and scroll down, I’m sure you’ll recognize some of the leading neuvo-web sites.

Now, seeing these successes described in IT Weakly (ha-ha) your average Joe IT Manager figures, ‘Hey! This Rails thing does web sites good! We have an in-house application to plan our customers’ parties which we need to upgrade, so let us rewrite it as a web-application using Rails!’

Gulp! Ding! Big Whoop! No good!

Why?

Because web applications and web sites are not the same thing… Joe IT is going to use Rails for something it is not meant for and actually quite weak for.

Web-Applications, a primer
To understand what web-applications in a deeper sense, consider the expression itself– it is naught but the well worn word ‘application’ with ‘web’ tacked in front. So a web application is simply an application that runs on the web as its platform of choice.

A desktop application’s experience is one of the user vs. The Software. Perhaps a limited remote resource is utilized, such as a query to the Party Supplies Database for the benefit of the purchase order printing screen but other then that– it is the user alone who calls the shots.

You can create deep, stateful use-cases that involve selecting a venue for the party and setting up the table locations and seating arrangements. It doesn’t matter if the experience of using this piece of software is immersive or merely tangential but the main point is that does not involve anyone else but the user himself along with the rich client experience (ah… Buzzwords). There’s a heavy statefulness to applications that doesn’t exist in web-sites.

The Thin Line
AJAX, another aspect of the Web 2.0 paradigm, is bridging the gap between the richness of a desktop application and that of one set on the web. It is also bringing more modal interaction to web-sites. But as thin as the line is, it is still there. And where it is most noticeable is the amount of statefulness of the software.

In a web site the state is maintained in these locations: The URL, the session and the database. You can consider them the short-term, mid-term and long-term memory of the software. For brevity, I’ll refer to any information which is kept client-side and travels back from the user as the URL, although it may be sent to the server in other parts of the HTTP request (such as forms).

To scale a web-site well, as little state as possible should be maintained in the session (for clustering purposes) and yet the cost of a DB call is also prohibitive so it is best for UI state to be contained in the URL as much as can possibly be managed, while taking care to never trust the user-sent data and to avoid assuming that he will ever traverse the flow chain as expected.

This leaves very, very little place for statefulness in web sites and it is the main reasons why web sites have shorter, shallower flows than do applications.

Don’t get me wrong– web-sites may have a rich UI. We are all immersed in the latest trend of enriching web-sites’ UI by creating a more responsive UI using AJAX.

The list that updates without a page refresh, a popup dialog for selecting your state or the modal window which display the clicked-upon photograph, these are just a few of the examples we see daily– but all this adds nothing to the statefulness of the site — it doesn’t turn it into an application and it shouldn’t!

Rails is ideal for developing web-sites because it deals very well with interpreting the current state from both sources (URL –> ActionPack, database -> ActiveRecord) and churning out a view for it. The second you add more statefulness, it gets painful.

Words of Wisdom
I speak from experience— I learned this painful truth about Rails the hard way by trying (and actually succeeding, through painfully so) to create a rich-flow application with Rails. This application should have been a desktop application by all rights, but seeing as I had recently acquired a hammer, I just had to use it to beat the screw in…

This application’s model was simple enough, but the user flow involved the use of resources on the PC itself (the DVD drive, in this case) making it utterly befitting a desktop application, and less so for a web-app… Blinded as I was by the ease of writing web-sites with Rails, I ignored my own red-lights flashing and went ahead anyway. It turned out well enough, but taught me hard lessons about what Rails makes easy and what it makes hard.

Statefulness…Blissfulness?
There are frameworks out there which fit a state-rich AJAX web-application much more than Rails. There are many examples and I would not want to mention one for fear of the flames, but feel free to suggest yours in the comments below.

Technorati tags: Ruby on Rails, Development, Software, Web 2.0

Bookmark to:

Basically, I think there’s only one feature missing that would make Google Spreadsheets the complete Excel killer.

What would make it truly an Excel killer is to allow one to reference data in other public spreadsheets just as one currently references data in another sheet in the same spread.
Right now you can enter a formulae containing a reference to another sheet so: =ABS(sheet2!C7)

What I suggest is something like:
=ABS(http://mydomain/public/spread1#sheet2!C7).

To make it even more interesting, I suggest that a ‘public spreadsheet’ is any URL which returns a XML spreadsheet. So you can essentially reference any appropriate web-service.

Suppose you want your spreadsheet results in up-to-date Euro, simply reference the current Euro conversion rate, for example:
=SUM(C2:C18) * http://xe.com/reference/convert?from=USD&to=EUR!A1

Note: This is a hypothetical URL of course.

This could also allow a manager to build a spreadsheet that utilizes his subordinates’ spreadsheets, recursively creating a hierarchical tree that represent an entire organization and updated dynamically. Naturally this would require some sort of security policy etc., maybe Google can sell its application suite to corporations as an appliance?… But only once they get the managers hooked on Google Spreadsheet for other things first… ;)

I believe this suggestion could really leverage the online-ness of the Google Spreadsheet application. I would appreciate any feedback!

Technorati tags: Google, Excel.

Bookmark to: