In an Agile environment we try to creat “just enough documentation” and “just enough architecture”. To achieve this we need our source code to become a part of the documentation.
At this point most developers will jump in the air and all others will go “oooh NO”. The reason why we have such reactions is because developers think they don’t need to do anything and all others think the code is not readable. I must say that in the past the last argument was pretty much true, but all of this has changed or it needs to change fast.
Developers need to start creating more clean and readable code. The first reason why they need to do this is because the code gets better and is easier to maintain. The second reason is Developers need to be aware that the source code is part of the documentation, because they are not the only ones that need to be able to read it. But it’s not only the Developers that need to change, others in the project need to accept that the source code is a part of the documentation as well.

There are enough books, tips and principles to achieve this clean and readable code, some examples SOLID principles, Clean Code, Boy scout rule. To show what I mean here is an example.

Bad example, we can all conclude that this peace of code is not easy to read.

@Override
    public void onCreate(Bundle savedInstanceState)
    {
	context = getApplicationContext();

	// TODO: check for incoming intent?
	intentValue = null;
	checkForIntent(getIntent());
	super.onCreate(savedInstanceState);
	properties = PreferenceManager.getDefaultSharedPreferences(Beta_SMS.this);
	// Check if the account is valid, if not open the wizard (should happen only the first time you open the app
	if (!Utils.checkForValidAccount(properties))
	{
	    startActivity(new Intent(this, Wizard.class));
	}

	// Set the view
	Log.d(Const.TAG_MAIN, "Creating the view and the rest of the GUI.");
	super.onCreate(savedInstanceState);

	//allow custom title
	requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);

	setContentView(R.layout.betasms);

	//set custom title
	getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.title);
	txtTitleSaldoValue = (TextView) findViewById(R.id.txtTitleSaldoValue);
	txtTitleSaldo = (TextView) findViewById(R.id.txtTitleSaldo);	

	//show providers
	providers = getResources().getStringArray(R.array.providers);

	//get the rest of the ui components
	to = (AutoCompleteTextView) findViewById(R.id.txtTo);
	txtTextCount = (TextView) findViewById(R.id.txtTextCount);
	txtSmsText = (EditText) findViewById(R.id.txtSmsText);
	send = (Button) findViewById(R.id.btnSend);
	contact = (Button) findViewById(R.id.btnContact);

	// get the balance
	showBalance();

	txtSmsText.addTextChangedListener(new SmsTextCounter(txtTextCount));

	if (intentValue != null)
	{
	    to.setText(intentValue);
	}

	// auto complete contacts, show all phones
	phoneHandler = new PhonesHandler();
	to.setAdapter(phoneHandler.getContactsPhonesListAdapter(getContentResolver(), this));

	// Set the intent for selecting the contact
	intent = new Intent(Intent.ACTION_PICK, ContactsContract.Contacts.CONTENT_URI);

	// When taped it will fire up an intent for showing Contacts,
	// when a contact is selected it will return and fire up
	// onActivityResult function
	contact.setOnClickListener(new View.OnClickListener()
	{
	    public void onClick(View v)
	    {
		Log.d(Const.TAG_MAIN, "Double taped, show contacts");
		startActivityForResult(intent, Const.PICK_CONTACT);
	    }
	});

	// when send clicked
	send.setOnClickListener(new View.OnClickListener()
	{
	    public void onClick(View v)
	    {
		onSend();
	    }
	});

	// set focus on the sms text field
	txtSmsText.requestFocus();
    }

Good example, I hope we all agree when I say that this code is easy to read and to follow.

@Override
    public void onCreate(Bundle savedInstanceState)
    {
	Log.d(Const.TAG_MAIN, "Starting the application");
	// set context to a helper class
	ApplicationContextHelper.setContext(getApplicationContext());
	super.onCreate(savedInstanceState);
	setBroadcastReceiver();

	loadProperties();
	validateAcount();
	setView();
	assignUiComponentsToVariables();
	showBalance();
	checkIntent(getIntent());
	setListeners();
	// set focus on the sms text field
	txtSmsText.requestFocus();
    }

Both the first and the second example do exactly the same but the second one can be understood in seconds where the first one first needs to be interpreted. In the second example I left the “detailed” code out on purpose because it is not about the detailed code. When we talk about documentation we want to know more about the flow and the relations not the details. If done correctly the details should already be tested and can be reviewed by looking at the test cases.

There are lot of programming languages in the world, there is one for everybody. All those languages have something in common and that is that they are trying to help you solve a problem. But they all try to do it there own way.
Every company has struggled one way or another to chose what programming language to use for a project. If they haven’t then they probably chose what they already have been using. For those that have been choosing most of the time they were looking at things like, can we find experts, is the language fast, secure, does it help us solve our problems faster and tools for the language. But have we ever looked at code size or language syntax and decided on that as well? Probably not, but should we?

Let’s look at some “’Hello World” coding examples. Source

Java

class HelloWorld {
  static public void main( String args[] ) {
    System.out.println( "Hello World!" );
  }
}

C#

class HelloWorld
{
    static void Main()
    {
        System.Console.WriteLine("Hello, World!");
    }
}

C++

#include <iostream.h>

main()
{
    cout << "Hello World!" << endl;
    return 0;
}

Scala

object HelloWorld with Application {
     Console.println("Hello world!");
}

Python

print "Hello World"

We can see that Java, C# and C++ pretty much look the same, Scala is a little bit smaller and python the smallest. Warning: This is not a scientific comparison but one to help understand the point.

So would it matter that a software engineer only needs to write one line instead of 3 or 4? Is he going to be more productive, more creative? How about code maintainability, readability?

Does the code size and syntax really matter?

I would say, in most cases it does not. The reason why I think that is because for most languages we have great tools that do a lot for the software engineer so you don’t need to write all those lines, most of them get generated or added on the fly anyway. Regarding code maintainability and readability, no programming language has yet been discovers that makes a bad software engineer do those things good.
What matters is that the programming language should allow the software engineer to focus on his problem instead of breaking his mind about programming details. This is also the reason why languages like Scala, Groovy, Ruby are getting popular. Looking at these languages you could conclude that it seems that syntax definitely can matter sometimes.

Java 7 was released, so I gave it a spin to see what kind of improvements were made. While testing some new features I went online to look for not so obvious changes as well. Here is a short list of the new features and improvements in Java 7.

• Strings in switch
• try-with-resources statement
• More precise rethrow
• Multi-catch
• Binary integral literals
• Underscores in numeric literals
• Improved type inference for generic instance creation
• More new I/O APIs for the Java platform (NIO.2)
• Support for dynamic languages
• Better multicore and parallelism support

The list is not that big but still it has some handy improvements. Looking at the list it struck me: How long have I been using Java 6? Looking at the table below you can see that Java has been updated every year or two but the gap between Java 6 and 7 is five years.

Time does not tell the whole story but looking at the time frame of five years it took to release Java 7 and the feature/improvement list it makes me say “This is it?” Sure Java 6 has been updated a lot but still it doesn’t fit. We all talk about Agile, iterative development and try to convince people how it improves software but when we need to improve a programming language we throw everything over board. But not all is lost, if you look at the table you can see that Java 8 is scheduled for 2012. So let me be optimistic and believe that this was just a hick up in the Java improvement process.

I am looking forward to Java 8.

We all know that testing is important and since more and more companies started doing agile we all have learned that testing needs to be done on the go and not at the end of our software development. Where couple of years ago it was very hard to find teams with testers in them now you can find a lot of them. Besides that it was very hard to convince companies why you needed a tester on the go and why that was better and cheaper than doing “some” testing at the end. Now days it’s all much easier and companies understand the benefit of testing on the go instead of doing bulk testing at the end of the software development.

By doing agile software development we have learned that working with a well balanced team is a must. So adding developers, architects, designers and testers to the team is not an “real” issue anymore. But how about adding security specialists?

Following the security news here are 3 hacks that happened in a weak.

• Nokia Developer forum hacked
• Linux Source Code Repository Kernel.Org Gets Hacked
• DigiNotar Damage Disclosure

It’s not just those 3 there are many of them. As we go online in to the cloud and start exposing more and more services to the outside world we need to know that our applications are safe. This kind of responsibility can not be given to a software engineer or an architect it needs to be given to a specialist aka the security experts.

We struggled to get the tester in to the team and now that we have achieved that goal it seems we need to struggle again to do the same for the security specialist.

That’s why I asked my self: “Aren’t security experts in the old testers position?”

Last day I got a tip about this old article “Java Is A Dead-End For Enterprise App Development”. My first thought was: “Here we go again, someone who is claiming a programming language is dying. The never ending returning discussion.” But I read it never the less and this is the summery of the article as I interpreted it: “Java was good but now we need a new better programming language that fits all and can be used to serve the business better. Java now days is just to complex to allow business to be agile (aka change).” The original author doesn’t give us any alternatives but just tells us that the new language should provide us with the following: “Dramatically increase developer productivity.” and “Allow developers to delegate change to business end users.”.
There is nothing wrong with wanting a better programming language or wanting the business to be able to change quickly, but blaming it all on to Java or any other programming language in this matter is in my opinion just wrong. If you want to achieve these two things you should try this:

• Stop working the old fashioned way and start working agile. Let the business be in control and decide where to go and guide the “development team” to achieve this as fast as possible.
• Use the right technologies for the job, don’t be afraid to mix there is nothing wrong with that. If the server side can be done in Java and the front end in Javascript then let it be.
• Build small blocks that can be added, removed or changed easily if necessary. Trying to build big piles of unified software is not good.
• Believing that the today’s 4GL will solve all your problems is just a dream, as with every language you need flexibility to be an innovator.

These four are just a small set of what to do to achieve what the original author was preaching. Who knows maybe someday ruby or a new X language will step up to the plate and the businesses will leave Java alone but for now Java is here to stay. At the end a programming language is just a tool to perform what you want, changing the name will not solve your now day’s problems. Until the new perfect language comes out the four guidelines mentioned above can help to achieve the goal.

Integration frameworks are getting more popular because you can easily integrate services or you can use them to integrate partial application parts to one application. To show you how easy it has become to integrate we did a 10 Minutes Hands-On at the It-Eye open space and this was the working result of that.

What is Apache Camel?
Apache Camel is a powerful open source integration framework based on known Enterprise Integration Patterns with powerful Bean Integration.

Camel lets you create the Enterprise Integration Patterns to implement routing and mediation rules in either a Java based Domain Specific Language (or Fluent API), via Spring based Xml Configuration files or via the Scala DSL. This means you get smart completion of routing rules in your IDE whether in your Java, Scala or XML editor. source

What did we produce?

As always a POM file:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>nl.iteye</groupId>
    <artifactId>camel-example</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>camel-example</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-core</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-test</artifactId>
            <version>2.6.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

And of course we created some code:

package nl.iteye.camelexample;

import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.mock.MockEndpoint;
import org.apache.camel.test.junit4.CamelTestSupport;
import org.junit.Test;

public class CamelExampleTest extends CamelTestSupport {

    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {

            @Override
            public void configure() throws Exception {
                from("direct:startpoint").id("route1") //
                        .to("log:ex1.1?showAll=true") //
                        .convertBodyTo(String.class) //
                        .process(new Processor() {

                    @Override
                    public void process(Exchange exchng) throws Exception {
                        String body = exchng.getIn().getBody(String.class);
                        exchng.getOut().setBody(body.replaceAll("root", "testroot"));
                        exchng.getOut().setHeader("IS_PAYMENT", 1);

                    }
                }).to("log:ex1.2?showAll=true") //
                        .choice().when(header("IS_PAYMENT")//
                        .isEqualTo(1)).to("mock:endpoint2") //
                        .otherwise().to("mock:endpoint");
            }
        };
    }

    @Test
    public void test() throws InterruptedException {
        log.info("running test");
        MockEndpoint resultEndpoint = context.getEndpoint("mock:endpoint", MockEndpoint.class);
        MockEndpoint resultEndpoint2 = context.getEndpoint("mock:endpoint2", MockEndpoint.class);
        resultEndpoint2.expectedMessageCount(0);
        resultEndpoint2.expectedMessageCount(1);
        template.requestBody("direct:startpoint", "<root><name>abc</name></root>");
        resultEndpoint.assertIsSatisfied();
        resultEndpoint2.assertIsSatisfied();
    }
}

And that’s it, but what does this example do.

1. It Starts with a direct endpoint that receives a message
2. t ads an id to the route, this can be used to manipulate the route with JMX
3. Logs the message
4. Converts the incoming message body to string
5. It creates a custom processor
1. Replaces the root element name
2. Sets a header
6. Logs the message
7. Dispatches the messages to a endpoint based on the header

As you can see it is very simple to create routes, you can use a lot of pre build components and if those are not sufficient enough you can create your own. And for those that don’t like to do this in java you can do the same in xml.

For more information look at:

Apache Camel
Maven
Netbeans 7
Junit

On our last IT-Eye openspace meeting we got a great explanation of The Business Model Canvas from our colleague Tim Pinchetti. I found it very interesting to see how simple The Business Model Canvas is for sketching new or existing business models. As this was not a presentation but an open discussion we soon ended up in sketching a real life business model. While we discussed our new business model it was clear to me that the only thing you needed to know to be able to fully understand what the model meant were the 9 blocks on the canvas. When you know the meaning of those 9 blocks you are capable to sketch, understand or discuss The Business Model Canvas.

Here are the 9 blocks (source):

Infrastructure

• Key Activities: The activities necessary to execute a company’s business model.
• Key Resources: The resources that are necessary to create value for the customer.
• Partner Network: The business alliances which complement other aspects of the business model.

Offering

• Value Proposition: The products and services a business offers. Quoting Osterwalder (2004), a value proposition “is an overall view of .. products and services that together represent value for a specific customer segment. It describes the way a firm differentiates itself from its competitors and is the reason why customers buy from a certain firm and not from another.”

Customers

• Customer Segments: The target audience for a business’ products and services.
• Channels: The means by which a company delivers products and services to customers. This includes the company’s marketing and distribution strategy.
• Customer Relationship: The links a company establishes between itself and its different customer segments. The process of managing customer relationships is referred to as customer relationship management.

Finances

• Cost Structure: The monetary consequences of the means employed in the business model. A company’s DOC.
• Revenue Streams: The way a company makes money through a variety of revenue flows. A company’s income.

I found The Business Model Canvas very easy to read, easy to draw and the most important it gave me the chance to quickly understand a business. Besides understanding the business you are also able to see the relations between your customers and partners, you can maybe even figure out where your new opportunities are or where your business needs improvement. While sketching a new business you don’t loose any time in trying to create a right picture because the canvas has a small set of rules. This way you are free and have the opportunity to focus on you creativity like a true painter that is drawing on a canvas.

More info:

• Book: Business Model Generation
• Blog: Business Model Alchemist

Step 1:
Connect your iPad to your PC and make a backup with your lovely (sarcasm) itunes.

Step 2:
Download “greenpois0n” from here

Step 3:
Start greenpois0n and connect your iPad to your PC if it wasn’t connected already

Step 4:
Press the “Prepare to Jailbreak” button and follow the instructions.

Step 5:
Press the “Jailbreak” button. When the iPad reboots it will show commandline text on the screen don’t panic let it finish.

That’s it you have just jailbroken your iPad, have fun.

More than a month ago I decided I wanted to buy a tablet so I went searching for an android one. I found two candidates that suited my needs and those were the Archos and Point of View. Yes there was also the galaxy tab but I have plaid with it and in my opinion the screen is to small for my needs. At the end I just wanted a 10inch tablet. Besides that I already have the Galaxy S so buying the galaxy tab would feel like I was buying my phone with a bigger screen.
Because Archos was not available at that moment I went for the Point of View. The speed and the external connections of the POV(Point of View) were great but there was a BIG draw back. And that draw back, you may call it game spoiler was the screen. I compared the POV against my Galaxy S and I could not live with such a bad screen, so eventually I just decided to return it.
Now there I was wanting a tablet but was left with no options. Because I hate waiting I just sad F… it and went and bought an iPad. The biggest reasons for buying an iPad were the screen and the fact it was available.

The iPad it self is great, it does what it needs to do and does it well. The screen and the speed of the device are great. I must say I am also surprised by the amount of the applications and the games that are available for it. There a lot of high quality games and apps that are really worth of having an iPad.

But not everything is that great on the iPad. Although people may say you don’t need flash my experience with the iPad was that there where a lot of times when I really need it. I also hate the fact that when I press install on an application the App store shuts it self down. The 256mb of memory is just not enough, I experience a lot of force closes because of the insufficient memory.

There are couple of things that you need for this:

• CPU that has hardware virtualization
• Virtualbox v3+

I am using the following:

• Ubuntu 10.04 64bit
• Intel CPU
• Virtualbox 3.2

To be able to install OS X you need OS X installation files, to make things easier there are OSX86 installation DVD’s going around provided by our lovely people at ihackintosh. I personaly used the iDeneb v1.5. To find these DVD’s just use Google.

Step 1:
Create an virtualbox image with the following options:

• OS as MAC OS X and sub option MAX OS X Server
• 1gig+ memory
• 20gig+ disk space

Step 2:
After creating the virtualbox image you need to change some settings on it:

• In “System” setting turn of the “Enable EFI (special Oses only)”
• In “Storage” setting change the IDE Controller to type = “ICH6”
• In “Storage” add the ideneb iso as CD-ROM

Step 3:
Boot in to your OS X installation

Step 4:
On the “Select a Destination” screen you need to prepare the disk for OS X otherwise you will not able to select it, to do so do the following:

• Got to “Utilities” → “Disk utility”
• Select the harddrive and erase it with the format option “Mac OS Extended (Journaled)”

Step 5:
On the “Install Summary” screen select Customize to add some additional settings to let it work, under iDeneb Patches 10.5.7 Ready -> Bootloaded and DSDT select the following:

• Chameleon V2
• DSDT Patcher

Step 6:
Proceed with the installation, after the installation is done before rebooting unmont the cd-rom in virtualbox.

Step 7:
Reboot and finish the post installation.

Step 8:
You have your self an OS X runing Have fun….