CEAN Erlang/OTP R12B erts-5.6.5 linux-x86 devel

You can find the version of Erlang installed with yum info erlang. erts version can be found by ls /usr/lib/erlang | grep erts.

After this when I tried to do any operation I received the following error,

** exception error: undefined function ibrowse:start/0
     in function  cean:geturl/3
     in call from cean:packages_from_html/1

Fixing this was simple. CEAN needs the ibrowse package which doesn’t get installed when you install it via yum. I was a bit confused at first because the site said,

If you already have an existing Erlang installation and want to use CEAN on it, you just need to download the CEAN library and extract the archive into your erlang lib directory.

Solution was to download the entire R12B archive from the site and to copy the ibrowse library to /usr/lib/erlang/lib.

Then you can install Erlsom by,

1> cean:install(erlsom).

Update: As it turns out this version of Erlsom getting installed via CEAN is an old one. You need to go to the SF project page and get the latest version and install it.

The chapter describing the role of governance during the analysis phase of a project was an eye opener for me because I had this wrong impression that SOA governance applied only to the components that is used in a service oriented architecture. This, as I later found out, called run time governance where you monitor the services to ensure they consistently deliver according to the governing policies and metric collection process for each and every service. In the chapter that’s dedicated to run time governance, Todd describe how to define provider/consumer baselines and how to manage them.

After guiding the reader through all the aspects of SOA governance, what should be done and how you should go about doing those, Todd paints a picture of what does it look like when you have implemented all these steps successfully. Then he explains how one can implement SOA governance in his/her organization along with some common challenges that one might face.

I thoroughly enjoyed reading this wonderfully well written book about SOA governance. You can read a sample chapter about service versioning here.

$ export MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=128m"

First step, build Axis2 1.4.1 from the custom branch

$ svn co http://svn.wso2.org/repos/wso2/branches/axis2/v1.4.1 axis2-1.4.1-branch

Next find the revision of the branch,

$ cd axis2-1.4.1-branch
$ svn info
Path: .
URL: http://svn.wso2.org/repos/wso2/branches/axis2/v1.4.1
Repository Root: http://svn.wso2.org/repos/wso2
Repository UUID: a5903396-d722-0410-b921-86c7d4935375
Revision: 32422
Node Kind: directory
Schedule: normal
Last Changed Author: amila
Last Changed Rev: 30518
Last Changed Date: 2009-02-06 10:39:03 +0530 (Fri, 06 Feb 2009)

Revision 30518 have an inconsistency in modules/addressing/pom.xml where the addressing artefact ID is wrong. You have to get this patch and apply it. Download, save it somewhere and do the following to apply the patch.

$ cd modules/addressing
$ patch -p0 < /home/chintana/addressing-pom.patch
$ cd ../..

Now you’re at the Axis2 root level. Before building at the root level you have to build two plugins,

$ cd modules/tool/axis2-mar-maven-plugin
$ mvn clean install
$ cd ../axis2-aar-maven-plugin/
$ mvn clean install
$ cd ../../..

Back at the root level, now you can build the project,

$ mvn clean install -Dmaven.test.skip=true

Next step is to build Rampart from the custom branch,

$ svn co http://svn.wso2.org/repos/wso2/branches/rampart/1.4.wso2 rampart-custom
$ cd rampart-custom
$ mvn clean install -Dmaven.test.skip=true

Build Sandesha from the custom branch,

$ svn co http://svn.wso2.org/repos/wso2/branches/sandesha2/1.4.wso2 sandesha-custom
$ cd sandesha-custom
$ mvn clean install -Dmaven.test.skip=true

Next up is Savan, again from a custom branch,

$ svn co https://svn.wso2.org/repos/wso2/branches/savan/1.0wso2v1 savan-custom
$ cd savan-custom
$ mvn clean install -Dmaven.test.skip=true

Now all the prerequisites are complete for the Carbon platform. Let’s go ahead and build Carbon. It has 3 parts. carbon-orbit, carbon and carbon-components (for carbon I had to change the addressing.version property in root level pom.xml to 1.4.1),

$ svn co http://svn.wso2.org/repos/wso2/trunk/carbon-orbit
$ cd carbon-orbit
$ mvn clean install -Dmaven.test.skip=true
$ cd ..
$ svn co http://svn.wso2.org/repos/wso2/trunk/carbon
$ cd carbon
$ mvn clean install -Dmaven.test.skip=true
$ cd ..
$ svn co http://svn.wso2.org/repos/wso2/trunk/carbon-components
$ mvn clean install -Dmaven.test.skip=true

All righty! After this you can go ahead and build other products which are designed on top of Carbon such as WSO2 WSAS, WSO2 ESB etc…

The main annoyance I faced was the lack of a proper error reporting mechanism. When you have an error on your controller, the script that starts the server simply refuse to start you can see the following VERY helpful error message in the console.

Unknown error
Compilation failed in require at /usr/share/perl5/Catalyst/Utils.pm line 270.
Compilation failed in require at ./script/stocktrader_server.pl line 55.

You cannot find out where the error occured. Only conclusion that you can make out of this is that there is an error in one of your controllers. Errors in models are shown correctly as they should. Template errors can easily be fixed. If you haven’t been doing incremental development, meaning you add a little bit of code then start the server and see whether everything has worked ok up to now, you’ll be in serious trouble. If you have the habit of writing large amounts of code without testing and keep testing for the last minute, Catalyst will torture you and put you through hellish debugging sessions for hours. I spent an inordinate amount of time trying to figure out the error and finally spotted that I’ve forgotten to make a single variable lexically scoped with my.

I also configured Log4perl to log all the errors to a log file and enabled the option to log warnings. Sadly I could not see any more log messages than I see in the console.

That aside, Catalyst is a fantastic framework to write web applications if you know Perl. As a big fan of frameworks it’s so exciting to see high quality open source MVC frameworks being developed that drastically reduce the effort of building web applications. Whatever the language you’re comfortable in programming, you can easily find a decent MVC framework for it these days. Well .. almost.

Catalyst is a MVC framework written in Perl. If you’ve written any applications with Ruby on Rails or Django, the first thing you’ll notice is, like anything written in Perl, speed. Also, another difference that I see with Catalyst is the unprecedented flexibility it gives to the hands of the application developer. For a framework providing this level of flexibility, Catalyst is surprisingly easy to program with. Will write more about my Catalyst chronicles in another post.

Introduction gives the reader a head start about what REST is all about and tools needed to play with RESTful web services. Then PHP libraries and function used for talking to a REST service is explained. How CURL is used to send requests with various HTTP verbs such as GET, POST, PUT, DELETE are explained with examples. After getting an XML response from a service, PHP libraries for manipulating XML and extracting parts of data you want is illustrated with samples. One could directly copy and paste these codes and try it out as they read along. Then the author goes on to explain how to use Flickr with PHP using CURL. If you’ve been using a high level library that insulate the lower level details, this example shows some of the basic API calls and how to use them.

After explaining a mashup of BBC news feed and Yahoo search API, author explains how to design RESTful services. This is carried out along with the simple but complete example of a library system. How to provide a service as well as consuming that using PHP and CURL is explained with complete code samples. Then he explains how to design the same thing using the Zend Framework.

The book concludes with a chapter dedicated to debugging REST web services. Using the TCPMon tool to capture messages and look for possible errors. The chapter ends with a set of best practices that everyone should be aware of if you do any programming with REST web services. The book also mentions WSF/PHP as an advanced framework providing many more functionality amidst of acting as a REST framework. I highly recommend this book if you’re a PHP programmer waiting to get your hands dirty designing RESTful applications. To whet your appetite here’s a sample chapter from the book about designing and implementing resource oriented clients. Enjoy!

For the uninitiated it might feel that choosing a low cost middleware platform is like choosing low cost, small, fuel efficient car. Anyone having driven a cheap small car would feel that it’s not as comfortable as a huge fuel sink SUV. Also your cheap model might not have all the features as the SUV.

When it comes to software however, things are different than the real world. Going for a low cost alternative does not necessarily mean giving up the features that your other big, greedy solution had. It’s like driving a Hummer with the fuel efficiency of a Prius. Who wouldn’t want that? Take it for a test drive and see for yourself!

Sliding through the walls they did. Taking all the heated souls with them. Leaving behind the gruesome coldness to me.

Rush of blood through the veins increased with the frequency of tingly murmurs. Common misinterpretation of the place as an escape destination was not to be found no matter how hard I look. Leaving no trail, taking the spots of memories as their neighbours went to do their magick.

Magick, magick, magick …

Plagiarism in written material is harder to detect unless you have read the original article/book etc… It’s a whole different scenario when it comes to web publishing. Anyone can search a vast repository of published content and detect phrases copied from other sources in just seconds. It’s common in academic institutions. But it’s disgusting when grownups just copy paste shit from the internet and publish under their own name. If you’re such a mindless moron, please do spend two minutes to rephrase your sentence in a different way giving the same meaning.

I can understand someone getting carried away with Google and Wikipedia and suddenly claiming to be an expert on anything imaginable. I don’t have a problem if someone is making a living off Google and Wikipedia, they should at least have the decency of mentioning the source where they read it. Or Ctrl-C Ctrl-Ved it. Whichever applicable.

So is open source the miracle cure for every proprietary solutions that cost a fortune on an yearly basis? Although some people talk like it is, reality is much different. A typical CTO will be reluctant to give up an existing deployed solution and go for an open source alternative. This might be for couple of reasons,

• The system works and it’s operational going offline is going to cost a considerable amount of money and business disruption.
• There’s no open source alternative out there that is a drop in replacement for any given large proprietary deployment of an ERP, CRM etc…
• What would happen to existing data? Will they be migrated? Can they be migrated seamlessly?
• If it’s a large enterprise operating in many industry verticals, does the alternative ERP system have modules working on those industry verticals?

There might be much more reasons, and many more specific to a given organizational setup, I’m just trying to list some general barriers off the top of my head. Most of all a formal TCO study might have to be carried out in order to justify the decision to upper management.

This is one area where a proprietary vendor, take SAP for example, thrive. They have a single solution where you deploy, tweak some parameters, do a BPR and everything starts to just work. Looking back at open source software vendors, I’m not aware of a solution like what SAP has to offer. Although SAP is ridiculously expensive a lot of companies are willing to pay money to them. They do have one heck of a product that works for many different businesses. I’m not sure how Compiere is doing compared to SAP. Looks like they’re doing quite ok. But the 3rd party vendors developing extensions and modules for SAP are several times bigger than for Compiere (if anyone is aware of a quotable statistic please do holler).

Let’s take another example. If your company intranet is running on Microsoft Sharepoint and you want to ditch that and go for an open source solution what would you be looking at? There is no single open source solution that you can compare with Sharepoint. Sure you can get a set of open source projects, put them together and make it your infrastructure. People who have done this knows how hard it is. Getting two separate projects to work with each other can often be described with the word nightmare. They’re not built to integrate. Most of them does not expose their data as Web services so you don’t have an effective method of accessing those. IMO, it’s another area where commercial offerings of open source projects can partner with each other and provide more integrated solutions rather than single products.

If you’re a tech startup you could probably put up with 5 different passwords for 5 different systems that you have to use. Wiki, CMS, bug tracker, forums and webmail. Giving single sign on between the applications is an important factor from an end users point of view. It certainly make the system easy to use and accessible. True, you get software like CAS but a couple of years back when I took it for a spin getting it to work with different apps turned out to be a colossal pain in the arse (it might have become more developed with great many plugins for different systems now, I haven’t looked at CAS recently). Doesn’t have to be that way. For solutions like this, built with open source, people are willing to pay money yet nobody is doing it.

So, I believe it’s a great time to think in terms of integrated solutions rather than individual projects and take those open source projects, make them easier to adopt and integrate into a wider enterprise environment.