Obviously, this title is a little provocative and there is a lot of shortcut . I am myself doing architecture and software development, and I have a recurrent  rhetorical question tickling in my head; where does a particular artifact should be build.

Indeed, a common pattern in software development is too find the right boundaries, the right frontier, the right position, the right size:

• Where should I decompose my software into service,
• Where this module should be separated from another,
• Where is the frontier between meta-data (configuration, …) and data.
• Where is particular class should settle, in the GUI part, the back-end part, …

Mostly, we agree on principles, the hardest part is too put them in practice. Most the times, the remaining question is, where is the limit, the position, the size of a particular artifact (services, class, module, methods, …).

Manager has to deal with numbers, status, deadlines, very concrete facts. Architects has on different mindset; Principles, Patterns, more vague concepts even if they are often well described. Amusingly, one of this principles is to continue to code to not being too much in an ivory tour and forget all this numbers (sizing, deadlines, pragmatism, …).

Buzz word, we are all talking buzz word, SSO is one of them. What is Single Sign-On by the way?

A brief description would say that Single Sign-on is a solution to allow an end-user to use different applications using the same credentials. To give you an example, when I use modern web sites like Facebook, Dailymotion, yahoo I can use OpenID to connect to any of these applications. OpenID keeps my user information and I may connect to any of theses websites with my OpenID ID .

Another incarnation of SSO in the enterprise world is described by OASIS using SAML. Security Assertion Markup Language is an XML based standard for exchanging authentication and authorization data between security domains, that is, between an identity provider (a producer of assertions) and a service provider (a consumer of assertions).

During the design of your application, security is one of the concern which should be handled before even writing a line of code. A simple pattern to allow to interact within an SSO compliant environment is to manipulate a Cookie object which will be linked to a Session object needed to  keep information across different user request. It’s a common pattern for web design but it could be applied to any application.

Whether you are using a SSO being able to keep session state for you (in a Servlet environment for example), or managing your session yourself using a database for instance, the Identity server will be able to link a particular user to this session object.

In a web environment, you can use CAS for example to centralize your authentication and authorization (source):

The following are the main steps in the authentication protocol.

1. The user attempts to access an application.  The user is redirected to the CAS login URL. The user is presented with a username/password dialog box.
2. The user enters ID and password details and CAS attempts to authenticate the user. If authentication fails, the target application never hears about it — the user remains at the CAS server.
3. If authentication succeeds, then CAS redirects the user back to the target application, appending a parameter called a ticket to the URL. CAS then attempts to create an in-memory cookie called a ticket-granting cookie. This is done to allow for automatic re-authentication later — if present, then it indicates that the user has already successfully logged in and the user avoids having to re-enter his username and password.
4. The application then validates that this is a correct ticket and represents a valid user by calling the CAS serviceValidate URL and passing the ticket and service name as parameters. CAS checks that the supplied ticket is valid and is associated with the requested service. If validation is successful, CAS returns the username to the application.

Using the username, you can provision your rights and roles from it. Either you can redo the same operation on every request or keeping this information within the current session. The link between the “cookie” and the session is then established. The session store the credentials necessary to access to any resources protected by security.

This pattern might be used within any environment. Apache Shiro (previously JSecurity) has been driven by this approach where authorization, authentication and session management are available within the same framework.

Adding Session Management within a security framework allow to take advantages of powerful features very easily. You can, for example, use Shiro in any environment (web or non web) where clustered or distributed sessions are desired. If sessions are federated across multiple applications, the user’s authentication state can be shared too. Log in once to any application and the others all recognize that log-in. Very simple in mind and very powerful to use, the only drawback of this framework is that is not compatible with JaaS, the java authentication and authorization standard.

Why choosing XEN Hypervisor for your virtualization.

Two reason, on Linux, it’s the most advanced open-source virtualization system. Even if KVM is under heavy development, many features are still missing. Second reason is that Xen has a paravirtualization.

The first part of the How-To would be to explain how to install Debian and Xen. I’ve done this many times and I will probably do a How-To someday to explain how to create this first step. Let’s assume you are hosted on OVH (European Hosting Provider) and everything is already in place.

The first step would be to prepare the LVM to allow to expand easily your partitions.

umount /dev/md2

Let’s assume we have an RAID array and you already have well partitioned your disks (like OVH does)

We create dedicated volumes for our Ubuntu Server 9.04

pvcreate /dev/md2

vgcreate /dev/md2 <GROUP_NAME>

lvcreate /dev/md2 –name <VOLUME_NAME> –size <SIZE> <GROUP_NAME>

mkfs -t ext3 /dev/<GROUP_NAME>/<VOLUME_NAME>

This will create the dedicated LVM volume for your Virtual Machine Ubuntu 9.04.

Next you will install directly without reboot your operating system from debian. Do prepare your installation you need to mount the volume group within your local file system.

mkdir /mnt

mount /dev/<GROUP_NAME>/<VOLUME_NAME> /mnt

Now, we will prepare the installation scripts :

http://ftp.us.debian.org/debian/pool/main/d/debootstrap/debootstrap_1.0.15_all.deb

dpkg –install  debootstrap_1.0.15_all.deb

Now, we have the scripts needed to install Ubuntu within a directory (our LVM partition).

debootstrap –arch amd64 jaunty /mnt http://archive.ubuntu.com/ubuntu

This phase will take few minutes, it will install Ubuntu 9.04. Once this done,  the next steps will be used to configure the target ubuntu system.

The first operation we need to do is to create a virtual terminal to allow xen to connect to this particular VM. We will modify /mnt/etc/event.d/xvc0

# xvco – getty
#
# This service maintains a getty on xvco from the point the system is
# started until it is shut down again.

start on stopped rc2
start on stopped rc3
start on stopped rc4
start on stopped rc5

stop on runlevel 0
stop on runlevel 1
stop on runlevel 6

respawn
exec /sbin/getty 38400 xvc0

This will allow to start getty process to allow xen console to connect to this terminal. Now we need to create the terminal itself within the /dev filesystem.

mknod /mnt/dev/xvc0 c 204 191

Next step is to allow network connectivity by modifying the file /mnt/etc/network/interfaces

# The loopback network interface
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
address <IP_DOMU>
netmask 255.255.255.255
post-up /sbin/ip route add default dev eth0

We need to setup now, the minimum file system needed to make our virtual machine working, we will modify the regular file /mnt/etc/fstab

proc /proc proc defaults 0 0
/dev/hda1 / ext3 defaults,errors=remount-ro 0 1

We can now configure the password for root and umount the VM filesystem

chroot /mnt passwd

umount /mnt

We are now going to create the configuration for xen to allow our system to run. We assume the xen configuration use vif-route to manage routing between Dom0 and DomU Operating System.

kernel=”/boot/<YOUR CURRENT KERNEL>”
memory = “2048″
maxmem = “3072″
name = <DOM0_NAME>
vcpus=2
vif = [ 'ip=XXX' ]            # replace with DomU’s IP
netmask = “255.255.255.0″
gateway = “XXX”                       # Dom0
disk = [ 'phy:/dev/<LVM_GROUP_NAME>/<LVM_VOLUME_NAME>,hda1,w' ]
root = “/dev/hda1″
extra=’console=xvc0 xencons=xvc0′

We can now create the VM with this configuration file set within /etc/xen/<VM_NAME>

xm create /etc/xen/<VM_NAME>

xm console VM_NAME

Note: You might want to make your vm starting in the same times than the Host. In some configuration you will have an /etc/xen/auto directory where you can put your configuration file.

You can now use your Ubuntu on top of Xen 3.2 / Debian 4.

Back in 2001, when Steve Jobs released Mac Os X, I was enthusiastic.

At last, one operating system based on UNIX with all its powerful tools been available and still the best User Interface we can have. In this period, Linux was far away from Ubuntu 9.04 and Windows 2000, well, Windows, except with cygwin, they were no way to have a real powerful command line (ok I’m a geek ). I remember saying to my friends that it was a good move from Apple.

Before Jobs came back to Apple, Mac OS 7/8 was a ugly OS based on the same approach than Win 3.1. That was six years after Windows  95 and the first preemptive scheduler offered to the end users.

In a great move, Jobs ask to its kernel developers to not been tight to any processor… 2005, Mac on Intel! Second great decision. Then, you were able to make run Windows and Linux (Ok, it was possible before, but with an very slow emulator.)

Apple had always had the strategy to package software with hardware altogether. Like its slogan (Think different), this approach has been partially deprecated during the 90’s where the industry focused on only its core business. Even company like Sony re-focus their activity on what is the most profitable and left aside plenty of products.  Many (and probably myself) had said during this period that Apple was dead. Keeping an exotic software (or hardware depending on people view) was too much expensive and prevent the company to sell their configuration.

Since, Steve jobs came back and with him, its desire to create products where all details are polished. Having this approach to bundle a complete solution (hard/software) make Apple force today.

To conclude, we have here a good hardware and a good software extremely well finalized (most of the times…). Therefore, the reasons why Mac OS X is my primary operating system today are quite simple : Unix tooling with a GUI focused on real user experience.

Maybe, Apple surf on the geek mode, maybe it’s just temporary, Windows 7 will be released soon and many people seems astonished. Still, no real Unix tooling and you should look at this link. Future might be bright for Apple.

N.B: I took the liberty to post a french picture of Mac OS X architecture, I’d like the old style of it

As you will probably discover, OSGI community is a very vibrant community. I will continue my articles around OSGi with some thought on the Spring flavor of OSGI as a plaform.

Spring DM Server is a product based on Spring OSGI open source project which have a goal (like always with Spring) to  encapsulate OSGI plateform to let you focus on your business code.

Then, here an insight of what Spring brings to OSGI…

Usually, OSGi services (obviously we are in the SOA world) has to be declared by using an API, OSGI Dynamic Service allow you to declare by configuration your service but you can’t manage services dependencies (half of the path has been done, “dommage”). Here an example how to declare and get service reference within OSGI :

It almost enough, still, you need to write some code and your application need to have OSGI jar during your test. Also, if you don’t want to deploy you application within different environment (OSGI, regular JEE, plain J2SE…), it will be difficult.

Here comes Spring and its magical IoC pattern (ok , it is not a patent of Spring ). Soon I will write a long article around Dependency Injection pattern.

By applying the IoC pattern, you can define and make the dependencies of your OSGI service within a simple XML file. The benefices are evident, no more code attached to OSGi, less code to write (and maintain), and automatic management of dependencies (in theory…).

In addition of the OSGI platform, Spring DM Server comes with Tomcat to help you deploy your web application. If you don’t need the full JEE stack, Spring DM could be the solution. It allow you to use old plain War and also a new concept based on OSGI (quite similar to Tomcat Webclass loader) which allow a War to use (by using OSGI dependencies) shared jar. Much more powerful than the old Tomcat approach where you where literally in a sandbox. Here you can manage what can be shared/exposed to your wars.

I will not go too much in details on Spring DM, the idea here is really to focus on the OSGi part. So, at least too related things are missing which make developer being frustrated.
First, they are no way to set a start level within the application context files of Spring OSGI configuration. The second issue, more related to OSGI itself, mandate developer to use PAR (“multiple bundle” packaging made in Spring) to deploy your application, which is dangerous; you tend to tight yourself to a particular application server.

Nothing is perfect in this world, Java and its class-path make developer life difficult with the Jar Hell, OSGI came with a new buzz word, the “bundle dependencies hassle”.

You can find Spring DM OSGI (or Spring DM Kernel) within Felix Karaf, a Apache project in incubation which has the goal to create core services on top of OSGI (Provisionning, Dynamic declaration (Spring DM), SSH Access, and many other killer features).

Karaf was first developed within Apache ServiceMix project (the Apache ESB). So, there is still many thing related to it. However, Karaf seems to be a really promising project as it cover many issue needed in the entreprise world OSGI itself had let aside (Its primary plateform was the Mobile industry).

With almost all major vendor adopting OSGI, Spring OSGI (open source project) or Spring DM Server (Spring product) could play a great part. Spring philosophy (I hope it will stay this way…) to focus on the principal (KISS Principle) might be a good solution for small and medium business who need to develop web application without all the payload of JEE.

Typically, I had to do this to modify the DZone plug-in which had some ugly configuration to modify the post subpanel in the Wordpress administration page.

Then, here the few things you need to do to create a beautiful meta-box within any Wordpress post page

This code will works for any version of Wordpress 2.x. Since wordpress 2.5, a new API has been defined to allow easily to add admin meta-box but if you want to create a plug-in compatible with older version of wordpress, here is the way…

First in your plug-in page add this piece of code. It will direct wordpress to listen any event of adding more stuff in the post page :

This step done, you need to write a php function which will handle this “event” :

You just had now to write your own “write_meta_box_content” function.
Of course, using Wordpress 2.5+, by adding an “event” to the action “do_meta_boxes” you can add meta-boxes everywhere they are used.

Here, as you can see, my admin post page look good now

For those of you who would like to have the modified plug-in working directly here is the link :
dzone-widget

Before talking about distribution, I will talk a little about OSGi.

This platform was primarily intended to work on mobile device. Therefore, it has been design to be light and focusing on the principal (KISS Principle).

Every developer who had used Java programming more than just some Hello World tests, will understand the Jar Hell and the fun with the Class-path.
OSGi has too primary goals, first its modular system which allow to manage module (they call it Bundle) life-cycle, module version management and module dependencies. It’s particularly important for applications who need to run with small memory to only load what is necessary.
The second important goal of the core of OSGi is its service registry, once again focus on the minimum and just allow a module to register its services on the registry in a really purely manner.

The OSGi consortium create many default service, some very generic (logging, security, web server), other more dedicated to a mobile platform (Power Management, Device Access, …).

Today, OSGi specification has spread to the enterprise world, most Application Server vendor bundle their infrastructure with OSGi within its core (JBoss, WebSphere, Glassfish, Jonas, Spring DM…).

As you probably know, or you starting to understand, OSGI seat right on top of the JVM and act as a kernel in our application. What will you say, if, now, without having to change one line of code, you can distribute your bundle on separated node. Nice on paper, DOSGi bring you that.

Today, only one implementation of OSGI 4 R4.2 (which contains DOSGi) is implemented by Apache CXF based on Web Services. I’m pretty sure tomorrow, other implementation will emerge with more performing RPC-like protocols.

At the OSGi service level, you will be able to discuss transparently with another service without knowing where the service is hosted. You just have to choose only at deployment phase where you want to distribute or not some of your services.

Going a step ahead, Eclipse Foundation is working on two promising project around this approach. Since Eclipse RCP choose OSGi for managing its plug-in on client, they had remove completely the old client/server paradigm. You can just using a service wherever it is hosted.

There are two different projects on Eclipse Incubation around this approach :

• Eclipse Riena : This framework being develop is the foundation to develop multi-tier application by exposing services in a transparent way.
• Eclipse Corona : Using events and actions on top of OSGi, this project aims to deliver a very efficient interaction between eclipse clients and server side to allow collaboration tools.

For those of you who are Netbeans addict, I know there are some, really, somewhere in the back of the classroom . Hopefully for you guys, people from the Netbeans community are doing some research to make OSGi bundle first class citizen in your favorite RCP .

The dry principle, Don’t Repeat yourself is the second principles in my series of architecture principle I will write on.

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

I’m often talking about “meaning”, every piece of software should have only one meaning, other says responsibility. Therefore, if we have applying correctly this pattern, every times we have to made a change into our software, we don’t have to re-factor the whole stack. Exception of the cross-cutting concern (i18n, security, logging, …), modifying a module should not impact another module.

I’m not fan of code generator (someday i will write an article on that ), but for the sake of this principle, I think i would prefer having some code generation than having to copy/paste code. As long as the code generated is NEVER modified, it’s fine.

A simple example I have used lately, I’ve made some test on GWT (Google Web Kit) to see if it’s mature enough to be used in my company.

When in GWT, you want to publish a “service” to your GUI you have to use 2 interfaces:

and

You write the first piece of code, which will be a simple RPC service usable within GWT, and the framework could generate for you (to allow async call) the second interface. It’s preventing you to have to write yourself this piece of code. It seems really minor but the principle is really well understandable with this simple case.

Talking of copy/paste, another part related with the DRY principle is to apply the OnceAndOnlyOnce pattern. Sometimes, I’m saying to myself, I should create a driver which deactivate copy/paste on developper computer .

Copy/Paste; there are two major issue by using the copy/paste “approach”, first you likely hand up having more bugs in your software.  I’m pretty sure, that if Gartner made some analysis on the bug causes in the software industry, copy/paste will certainty be in the top 3.
Have you already try to make a software evolve when most of the code is a crappy copy/paste with just few changes between copy. Believe me, you will, one day, and this day, your week (and maybe more) will be boring . You end up having to re-factor all the code with the certain probability to introduce a bug. We have to factorize upfront!

DRY doesn’t mean “being lazy”, although lazy could be a pattern it’s not the subject here . We should don’t hesitate to always refactore our code, every times we add some portion of code even it’s not ours.

Steve Balmer like to put word in your head just with just a little insistence , I would apply its pattern : “Factorize, Factorize, Factorize!!!” your code.

As all Apple user, you fill frustrated because you don’t know when you will buy your new equiment if a new one will come . Hopefully, macrumors has created a guide for you : http://buyersguide.macrumors.com/. It’s time to buy a MacBook pro with Snow Leopard on It

I will write a series of article around architecture principles I follow.

Often, in the software industry, it’s hard to say “STOP, this software doesn’t need more”. We have a tendency as human to  wants more and we apply this pattern (Yes, I have said the word “pattern” ) to our software.

Therefore, following the KISS principle could be against nature. Every times I starting to design a component, writing some code, creating a information system architecture, I keep saying to myself, “do we really need this ?”, “Is that is not too much complicated ?”, “Is there something simpler to do the same job ?”…

I will become evangelist here. I see this principle as the prime principle . Before thinking of DRY or SOLID principles which are very important, as a whole, we should always keep modesty and try to add only what is really needed to our software. When i mean “add”, I mean, features, 3rd Parties libraries, source codes , commentaries…

By the way, I like this quote on the wiki link :

The principle most likely finds its origins in similar concepts, such as Occam’s razor, and Albert Einstein’s maxim that “everything should be made as simple as possible, but no simpler”.^[2] Leonardo Da Vinci’s “Simplicity is the ultimate sophistication”, or Antoine de Saint Exupéry’s “It seems that perfection is reached not when there is nothing left to add, but when there is nothing left to take away”.