Leveraging Model Driven Development

Achieving efficiency in the software development process is one of the key motivators every team should strive for. Efficiency can be measured in a variety of ways. The most obvious measurements are cost, project timeline, and the feature set that can be implemented given the first two. In a sense, it boils down to the old project triangle (remember: pick any two of the criteria).

In essence, there is a trade-off between quality, timeline, and cost. For example, reducing the timeline at equal costs reduces quality just as implementing at a faster pace reduces quality. Yet I argue that the triangle approach is not necessarily valid anymore. Traditional development processes have clearly shown that just enhancing the timeline on a project to put special care into the design does not actually lead to higher quality software – quite the contrary.

Yet more dimensions are at play. The number of defects (“bugs”) found in a particular software directly translate into cost and time, especially when found late in development cycle, creating a dependency between testing quality, time, and cost. Inefficient software design increases the cost of introducing new functionality as requirements change and a lack of refactoring capabilities sooner or later lead to the need for a full re-development. The problems are amplified when the software spans multiple independent subsystems, which is often the case in modern web architectures which span across content management systems, web services, search engines, commerce engines, custom web applications, etc.

Agile development methodologies have tackled many of these problems in great detail through test-driven development (TDD) and time-boxed iterative release cycles. This article discusses a number of tactics you can deploy in addition to what you find in your agile toolkit: To speed up development and tackle complex problems with smaller teams in less time leveraging the key ideas of Model-Driven-Development (MDD).
Read more

Interacting with Holograms

We’ve had a multi-touch Surface device at work for a while now and built a few neat prototypes with it. But this multi-touch emm multi-grab hologram looks way cooler. The demonstration shows a man interacting with holographic images projected before him, moving them around and resizing them. It’s only sort of like the Minority Report display, which used hand movements to control elements on a screen.

Jangaroo

My former colleagues at CoreMedia decided to release their Javascript cross-compiler, Jangaroo, as open source. The tool takes Javascript 2 / ActionScript 3 and translates it into browser-compatible JavaScript 1.x, allowing the developer to write the scripts in a much nicer — and more object-oriented language.

Here’s a sample JavaScript 2.0 class:

package net.jangaroo.example {

  /**
   * A simple example demonstrating how to receive and return typed arguments.
   */
  public class HelloWorld {

    /**
     * Returns a personalized greeting.
     * @param name name of the person to greet
     * @return String a personalized greeting
     */
    public function greet(name : String) : String {
      return "Hello, " + name + "!";
    }

    /**
     * Returns a personalized and HTML-escaped greeting.
     * @param name name of the person to greet
     * @return String a personalized and HTML-escaped greeting
     */
    public function greetHtml(name : String) : String {
      return this.greet(name).replace(/&/g, "&").
                                replace(/</g, "&lt;");
    }
  }
}

Once translated with the cross-compiler, you can import the classes into your HTML and use them:

 <script type="text/javascript" src="joo/Class.js"></script>
<script type="text/javascript" src="net/jangaroo/example/HelloWorld.js"></script>
<script type="text/javascript">
//<![CDATA[

// asserts that all required classes have been loaded
joo.Class.complete();

// instantiate the example class
var helloWorld = new net.jangaroo.example.HelloWorld();

// button onclick event handler
function sayHello() {
// grab the input and output elements
var outputDiv = document.getElementById("output");
var inputField = document.getElementById("nameField");

// call the #greetHtml method of the HelloWorld class, and output the return value
outputDiv.innerHTML = helloWorld.greetHtml(inputField.value);
}
// ]]>
</script>

Check it out on jangaroo.net.

NextStep Timewrap

The original demo from ‘92. So if anyone ever tells me Hibernate is such a new technology… whack ;-)

Goosh!

This is totally awesome, the (unofficial) Google shell — a command-line friendly way to search Google in your browser. I’m all over it.

help



command
aliases
parameters
function


web
(search,s,w)
[keywords]
google web search


lucky
(l)
[keywords]
go directly to first result


images
(image,i)
[keywords]
google image search


wiki
(wikipedia)
[keywords]
wikipedia search


clear
(c)

clear the screen


help
(man,h,?)
[command]
displays help text


news
(n)
[keywords]
google news search


blogs
(blog,b)
[keywords]
google blog search


feeds
(feed,f)
[keywords]
google feed search


open
(o)
<url>
open url in new window


go
(g)
<url>
open url


more
(m)

get more results


in
(site)
<url> <keywords>
search in a specific website


load

<extension_url>
load an extension


video
(videos,v)
[keywords]
google video search


read
(rss,r)
<url>
read feed of url


place
(places,map,p)
[address]
google maps search


lang

<language>
change language


addengine


add goosh to firefox search box


translate
(trans,t)
[lang1] [lang2] <words>
google translation

1)	LinkedIn: Jochen Toppe Jochen Toppe’s professional profile on LinkedIn. LinkedIn is a networking tool that helps users like Jochen Toppe discover inside connections to recommended … http://www.linkedin.com/in/jochentoppe

Mac Virtualization

I recently got myself a shiny pretty 24″ iMac and was thinking about installing some sort of virtualization to run Windows. Since I don’t really need Windows for anything on a Mac, I thought I’d give open source, i.e. VirtualBox another try  (see my previous post) and look it works perfectly. Version 1.6 now officially supports Mac OS X and it’s free.

There are a few restrictions in running this on OS X, all things I can personally live with:

• No support for Host Interface Networking
• No support for Internal Networking
• No support for audio input
• No support for VT-x/AMD-V (rarely required)
• No support for raw disk access
• The numlock emulation isn’t implemented yet
• The VirtualBox kernel extension is currently accessible from all user accounts

So far I haven’t even needed Windows. Really, the only application I can’t find for Mac is the VMWare Server Console, but I can just ssh into my Linux box and run it — the beauty of OS X being a full Un*x operating system including X11 support!

Impact of Green Computing

I found an interesting article linked off of Slashdot. As an technology architect I’m very familiar with load balancing strategies and round-robins, but I’ve admittedly never thought about the impact of the load balancing strategy onto power consumption.

It’s very obvious though, by evenly distributing load across servers you end up with many servers with medium load. By assigning more load to an active cluster of servers, a smaller set of stand-by servers could shut down into power saving mode.

That also gives a new meaning to the unfortunate “let’s throw more hardware at it” mentality. Next time remember to bring up carbon emissions when trying to sell a client on spending a little more time on code optimization.

Anyhow, check out the whitepaper right here.

Virtualization

I just found an excellent article on the internals of virtualization (in software, paravirtualization and hardware virtualization). Check it out on AnandTech.

Enjoy!

Cool software

Sometimes vendors/products just stand out of the crowd. My personal top 5 coolest pieces of software at the moment:

1. Intellij Idea for making my j2ee work efficient
2. Ubuntu Linux Server for just being the easiest server distro out there (this site is served by version 6.06.2)
3. Camtasia for making really nice webcasts
4. Wordpress for running my blogs and home pages (despite the fact it’s written in php)
5. All Atlassian products

Functional Language Aspects

There’s been an interesting influx of functional programming aspects into mainstream object-oriented languages such as C# and Java lately. Of course languages such as Groovy and Ruby have been featuring these language elements for years. Let’s look at a few of these features:

Closures

Closures are parameterized anonymous functions which are bound to variables and evaluated in a dynamic context. This construct is also referred to as lambda functions (e.g. C#, Ruby, Lisp). .NET introduced Lambda expressions with .NET 3.5, Java will most likely introduce them with JDK 1.7. I find them very useful, but a little hard to debug sometimes. Some examples:

Java

{int=>int} addOne = {int x => x+1};

C#

Func<int,int> addOne = d => d + 1;
 // or
 var addOne = d => d +1;

Type Inference

Let’s look at this C# example:

var x = 5;
 object y =  6;
 x = "foobar"; // leads to error as x's type is int
 y = "foobar"; // works just fine

The type of x is inferred upon assignment (note that C# still employs static typing, however).

Java 7 will introduce type inference as well, even though it seems to be mostly constructor type inference to simplify syntax:

Map<String, List<String>> anagrams = new HashMap<String, List<String>>();  

// can be written as 

Map<String, List<String>> anagrams = new HashMap<>();

Fun Links

C# is a functional language: http://sneezy.cs.nott.ac.uk/fun/nov-06/FunPm.ppt
JDK 1.7 Features http://tech.puredanger.com/java7/
Type Inference http://en.wikipedia.org/wiki/Type_inference
Closures http://en.wikipedia.org/wiki/Closures

Next Page →