Remember Delphi ? Visual Basic? Borland C++ ?

What I’ve seen these weeks with Oracle letting Apache leaving the JCP Executive Committee  seems to lead to the “old days” where we had to buy a closed platform to work on. It was before Internet, the open source movement, Linux, Git, etc.

A world where we have to rely on a company to have support, when we can’t make our C++ COM object working properly without MSDN subscription. A world where Delphi was a good tool for creating GUI (sic). A world were Visual Basic was one of the most used language.

Oracle has understood that the Java Language itself doesn’t worth any money, the JVM does. They don’t want to let an open source alternative to compete with their own. They already start to sell an “advanced” JVM with support. That is the main reason why the prevent Apache to have their JVM being distributed.

Hopefully, these days are over and Internet has open everything. Source code, Social activities, Location, Diplomat cables… and even sometimes our Mind (I’m too much an idealist sometimes ).

We have entered a new millennium with Internet and I feel like what Oracle has done this week is just like a short term thinking how to make some money. At some point, they will realize that it’s not profitable anymore to follow this strategy and change it.

Let me guess, in two or three years, if they continue to “close” the java ecosystem, a new rise will appear.
Hum, LLVM based software will start  to raise (Objective-C, Scala, Go?, …). Apple and Google already support LLVM for their language. Chrome OS  already has some port within there NaCl plug-in approach.  LLVM is also used by Apple in many places in there platform. There is already some Java port to LLVM plateform, we just miss  Scala integration and no-one will even care about Oracle trying to make money with the community works.

Java is Dead, Long live Java.

I’ve been presenting yesterday to RivieriaJug some slides doing an OSGi overview. I’m sharing them here.

Actually it does matter. It is just not always the right moment to optimize your code. There are several patterns applied properly at the start of most project helping you worrying about performance at a later stage. Obviously this won’t help if you need to do highly CPU demanding processing (neuronal network, nuclear bomb simulation, …).

First, the most  important design pattern to apply for performance and scalability is to being stateless. Keeping state in memory from the start of the project is premature optimization, it will prevent further development because you will have to leave with this small tiny stuff which does fast but not flexible for change. I’ve been working in different scenario and not being stateless has ALWAYS been a massive issue which require a lot of re-factoring for … nothing (in term of features). Never, whatsoever, do a state-full component, never. Take parameter, Compute, save in a persistence layer. That’s all! Ok, it’s a little provocative.

If you have done your design right, it will be very easy afterward to proxy your code and cache it only when it’s necessary, doing this in a second development phase allow to add/remove at will (even more when using Dependency Injection pattern) your cache.

You will also have simpler unit test in place since you will not have to test when you keep state in memory, so it will be easier to re-factorize afterward.

Second, design/develop against “contract”/interface, you should always specify APIs first. Relying on an interface allows you to change the implementation afterward if you need more performance and re-factorize a specific API. It doesn’t cost in term of performance (virtual invocation has minor impact in C++ and mandatory in JAVA anyway).

It permits also to “inject” a cache in the middle without changing the contract between the two parties for instance if you have a network I/O between them.

Third, always favoring API over DTOs/Values Object, DTOs over state-full component. Their is a very simple reason of doing that, it’s easier to proxy an API using its contract than optimizing a DTO/value object.

Obviously you won’t be able to do that all the times and you might need to transfer Object/Message or even having a state-full component (Session Management in a web farm for instance…), but the rules would be to always think API first, DTO only if necessary and state-full component when you’ve got your manager asking for something very quick and dirty .

Forth, (it grows…), always prefer event based approach. To gives you some examples, if you do processing which imply I/O, actually, if you do computer programming, you will always encounter I/O.

Anyway, let’s say you want to create a very fast and powerful HTTP server (something everyone should have made before 50 if he doesn’t want to fail in its life ), you will then create a multi-threaded server which create a new thread for each new client. You will miserably fail. How a CPU can handle 10000 thread with 2Mo each (by default on most OS) of memory allocated to it.

Most (all) of the modern operating system allows you to listen to events (in different manner) coming from the operating system. It’s help a lot, by removing the cost of calling a system call which implies various cost i will not explain here, and having a thread waiting for something to happen, being awaken, etc.

To design a powerful HTTP server (lighttpd, Nynx, …), you will have few threads (one by CPU is enough if you just want to serve static pages) and you will just register to events coming from the Operating System. Less context switch, 1 thread by CPU, less system calls and no wait which imply on a multi-CPU platform a lot of drawback when we talk about data bus (in the motherboard).

This pattern has to be applied every time you have I/O which can be blocked or slow compare to your processing. SAX handling when you parse an XML document is an event approach, Observation pattern is an event approach, etc…

Fifth, which is quite straight-forward, follow GoF design patterns, and more generically the separation of concerns principle. It’s not necessary to know 200 design patterns to cover 300 use-cases, just the GoF are fine enough to manage your needs and if you fill it’s not the right move, just look at this page to figure out if you really need more.

Let me give you an example.

I’ve been involved during my career in a project where one of the goal was to render web page using some sort of configuration files which contains details of the page. The legacy code was a bunch of functions actually doing “printf” stuff. It was a mess, un-maintainable, slow and not really bug-free.

My first re-factoring action has been to model our page using the Composite pattern representing an object tree of the page and using the Visitor pattern to make CSS, JS and HTML being rendered (CSSVisitor, JSVisitor, …). It make the page been rendered several times faster (HTML very clean, JS and CSS being cache by the browser) and even more flexible since we can render any kind of content from our model. Nice, simple, KISS.

To summarize, this “principles” are the primary steps for a performing and scalable application.

It will not prevent you to do profiling nor putting cache in place afterward, but it will help you do that efficiently without compromising the bunch of features your product owner, customer, whatever the name of your “features requester” is called have asked for.

Performance is ALWAYS a trade-off between I/O and memory, at the end, it will always end-up being a cache to prevent I/O to happens. You can re-invent multiple technique to improve performance, but even if you look at the CPU level, with its register and its cache, there is no secret, “caching” is the only viable option.

Now, it’s time to profile and optimize your algorithms , think about putting load balancing (easy since your services are stateless), put in place caches at many levels (within your code with WeakHashMap, against a database with NoSQL databases, some HTTP proxy if you want to serve web pages, …). Having created your source code following this rules will permits to do that quickly almost without re-factoring.

First, some brief overview of the two technologies. OSGi is a framework aims to create an component/plug-in software. I’ve already mention OSGi in a previous post.

SCA stand for Service Component Architecture. Oracle, IBM and others came up with the conclusion than SOA is just a buzz word and without a plain framework, everyone can say they do SOA development but actually doing something else … They have created several specifications to help to produce a SOA software. Key features are separation of concern, component oriented, dynamic binding, aggregation/composition of services/components.

SCA target high level / business services whereas OSGi is more targeting modularity at lower level.

Micro-kernel is becoming more and more popular (jboss, glassfish,…). OSGi coming from mobile has standardize a lot of “kernel services” (logging, configuration, provisioning), and now start to enter the enterprise, it’s helps a lot. Whereas JEE focus was on middle-ware infrastructure, OSGi gives a lot to manage what was left to developers. Dynamic loading in it’s hearth, OSGi make the perfect micro-kernel for those we want “always on” servers.

Obviously you will be able to leverage enterprises technology using Spring as it integrate OSGI very nicely using Spring-OSGi-Extender (Spring DM). It manage at startup to wire automatically OSGi services and components (bundles). This could become your first layer, this would be called the OSGi-Extender layer.

Core services might be our own business modules with your domain, repository and value objects or 3rdparty library/services like JPA implementation. Fortunately, OSGi enterprise 4.2 being just released, it’s where you will see this modules. SCA is even mentioned in this specification.

This composition of services/composant will be done and expose as a business service with multiple endpoint. It’s where we can see that the couple OSGi/SCA brings a lot and helps you focus on your business. OSGi modules to manage technical component for keeping DRY principles and SCA to expose business endpoint with automatic wiring and security enabled.

This schema taken from Apache Tuscany page express how SCA does the wiring between business services. As a typical SOA, you will expose your “contract”. Within SCA, you will configure additionally how you want to expose it (using RMI, WS or any kind of protocol supported by the SCA implementation you choose).
By doing so, you let decide protocol at deployment stage, not at development stage. It make your software very flexible and let you focus on your business code.

Managing modules/components and there dependencies require to use an automatized tools (maven, nexus) but it’s a different subject.

For reference, Apache Tuscany is an SCA implementation, in there next release (2.0) they will provide an Distributed OSGi using SCA). Apache aegis is an incubator projects providing most of jee “cores services” (jpa,jta,jmx,…).

C++0x is the standard which describe the new C++ language specification. It’s still draft. The main focus of the C++ committee is the development of the core libraries. In the language itself, the committee will introduce lambda functions (like Clojure, scala, groovy, ruby, php, …), nullptr variable (interpreted as a pointer whereas today NULL is a defined integer most of the times, it depends on the compiler) and few other minor changes.

Both Visual Studio 2010 and gcc brings support C++0x with their latest versions. I’m very curious myself to test lambda functions. For those of you who want to try them, you will find here the 2 tables describing which features each of the compiler comply with.

Visual Studio 2010 : http://blogs.msdn.com/vcblog/archive/2010/04/06/c-0x-core-language-features-in-vc10-the-table.aspx

Gcc 4.5 : http://gcc.gnu.org/gcc-4.5/cxx0x_status.html

It’s obviously too early to use it for production development, but worth spend some times to test these new “features”.

Java, as a mainstream programming language evolves to always trying to fit the latest needs. One big leap has been introduced in Java 5, with several language changes. One of them was the possibility to do some meta-programming. Big word isn’t it? Indeed, meta-programming.

In Object Oriented Language like Java, you will usually construct your software using object (cars, tires, engines …) and methods (move, turn, explode …) to describe your business into something computer will understand. Sound simple right?, in theory, this is pretty simple. Things become difficult when we need to save data, display things to a screen, connect to the network. Software engineer has invented APIs (Application Programming Interface) to help application developer to interact with 3rdParty libraries in general and display, network or system libraries in particular.

This is when our code start to be un-maintainable because we mix business code (cars, tires, engines) with technical plumbing (readfile, display, connect).

Java 5 has introduced annotations, a mechanism allowing to give information to our object without being part of it. Meta-programming. One simple example is the old “deprecated” keyword.

In java, you can say that a method will soon disappear, and to say that, you just need to “annotate” your method.

Today, many frameworks are “annotations” based, meaning you can describe your software behavior without even writting a line of code, just writting some annotations to your business code to make the “plumbing”.

After a while working with annotations, you will find it can become even more messy than an old spagetty plate. So, where are the limit, where should I use annotations, where should I not?

My opinion is, annotations are good for describing your code, but as soon as your annotation “does” something (@Inject, @In, @DoesSomethingWithoutTellingWhat ), you should avoid them.

To give you some examples, Hibernate in java allow to annotate your model (tires, cars, engines, …) and say what IS your model and describe it. Hibernate will pickup from this meta-information and save your data into a database. At the opposite, you will find Jboss Seam where everything is made of annotations, you can actually “do” plenty of stuff using annotation, this is where i found annotations useless. It doesn’t help code readability nor performance. It’s just a lazy approach to do stuff you don’t understand.

Obviously people will like them because they can produce something working in 5 minutes. But what after these fives minutes, it will took more times to understand what the annotations are currently doing than reading simple line of codes.

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 should a
particular artifact be built.

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 tower 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