Techila Shots

JNI/Win32:java.lang.UnsatisfiedLinkError

2010-07-02T04:13:00.000-07:00

I spent almost two whole days trying to solve this issue. I did everything possible from altering my c++ code (changing the return types) to compiling from command line rather than the IDE. Also, I tried a number of other steps like changing the classpaths, refactoring package names to changing names of the generated header files. Finally, I found the following resolution.

Whenever the C++ compiler (GCC) generates a DLL, it is exported in the following form:

Java_somepackage_SomeClass_someNativeMethod@8

Where the integer suffix suggests the byte space required by the arguments. This sort of function call makes no sense to the JVM (while invoking someNativeMethod) and hence it leads to java.lang.UnsatisfiedLinkError. The resolution is to add the following flags while linking to generate unmangled names:

-Wl,--add-stdcall-alias

This will create an alias name (pure method call name) to the generated method. This allows the JVM to invoke the right method via JNI.

I almost gave up on this issue, before I finally found this resolution. The point to note here is that this happened to me only on Win32 - I had no issues running on the UNIX platform.

Clash of the Titans, C++ vs Java!

2010-05-28T22:55:00.000-07:00

As a software engineer, the mind is trained to seek optimizations in every aspect of development, and ooze out every bit of available cpu resource to deliver a performing application. This begins not only in designing the algorithm or coming out with efficient and robust architecture, but right onto the choice of programming language. Most of us, as we spend years in our jobs - tend to be proficient in at least one of these.

Recently, I spent some time to check on the performance (not a very detailed study) of the various programming languages. One, by researching on the internet; Two, by developing small programs and benchmarking. The legacy languages - be it ASM or C still rule in terms of performance. But these are definitely ruled out for enterprise applications due to the complexity in development, maintainability, need for object orientation and interoperability. They still will win for mission critical or real-time systems, which need performance over these parameters. There were languages i briefly read about, including other performance comparisons on the internet. These include Python, PHP, Perl and Ruby.

Considering all aspects and needs of current enterprise development, it is C++ and Java which outscore the other in terms of speed. According to other comparisons [Google for 'Performance of Programming Languages'] spread over the net, they clearly outshine others in all speed benchmarks. So much for my blog title :-)

So when these titans are pit against each other in real time, considering all aspects of memory and execution time - Java is floored. Though I have spent last 7 years of my life coding and perfecting my Java and J2EE skill - I suddenly feel... Ahem, Slow! One of the problem statements to verify this is given below (alongwith the associated code) and the associated execution parameters.

[Disclaimer: Problem Statement given below is the property of www.codechef.com]

In Byteland they have a very strange monetary system. Each Bytelandian gold coin has an integer number written on it. A coin n can be exchanged in a bank into three coins: n/2, n/3 and n/4. But these numbers are all rounded down (the banks have to make a profit). You can also sell Bytelandian coins for American dollars. The exchange rate is 1:1. But you can not buy Bytelandian coins. You have one gold coin. What is the maximum amount of American dollars you can get for it?

Input
The input will contain several test cases (not more than 10). Each testcase is a single line with a number n, 0 <= n <= 1 000 000 000. It is the number written on your coin.

JAVA SOLUTION

C++ SOLUTION

RESULTS

TIME	MEM	LANG
0.00	2.8M	C++ 4.3.2
0.26	218.3M	JAVA

I am sure these results will continue to be remain in the same ratio (with slight variations for other or benchmark problems) - even with the most optimized java code.

JAR Searcher Developer Tool

2009-01-31T10:33:00.000-08:00

As a Java/J2EE developer, I know that the most commonly faced issue in development, which has also been reported as the primary reason for developers losing hair - missing classpath files or not being able to trace a JAR which contains the file - when you know you have all JARs that could possibly exist in this world on your local file system.

Just wrote this simple tool, JarSearcher v1.0, which accepts the name of class file you are looking for and returns all the JARs on your system which contain this file. Also, for Windows developers, I have added a .bat file (Unix folks, kindly replicate .sh) which takes the following form for execution:

js [class-name] [start-in] -c

[class-name] The name of the class file to search (without .class)

[start-in] The directory in which to start looking for the files

-c This switch will toggle display of processing information

or you can directly invoke the program from the bundled JAR file:

java -jar jar-searcher.jar [class-name] [start-in] -c

I have included the source, feel free to modify it as per your convenience.

Spring - DWR - Ext JS Chat Application

2009-01-23T09:09:00.001-08:00

I was curious to explore the capabilities of Reverse Ajax. That's when I created this simple chat application using Spring/DWR/Ext JS.

From my experience, I can easily say that DWR is easy to learn and configure, especially when you are planning to integrate with Spring on the application tier. DWR has a powerful API to perform all relevant operations, right from accessing page script sessions to util classes for sending updates to the client.

I used Ext JS for creating the user interface, which renders stunning display for elements like forms, buttons, etc. Ext JS has a very steep learning curve and each operation requires a lot of configuration and reference. Also, I found that the event handling mechanism, though complete, is very complex to use. I relied on external Javascript coding for handling events. On the upside, the documentation and support is really good for this framework. Inspite, I would instantly recommend use of Ext JS for large sized customer facing web-based applications, especially for the internet. For medium scale projects or enterprise based projects, I would think twice.

Login Screen

Chat Screen

Simply, drop the .war file in your web/app server. All dependencies are available in the archive itself. The only external reference is 'servlet-api.jar', which is part of the default lib in all latest containers. The source is packaged separately. Once deployed, the url to access should be: http://[server_name]:[server_port]/kabootar/login.kabootar

If you are trying to figure out what 'Kabootar' means, it's hindi for 'Pigeon'...

JBoss Cache XSD Config in Eclipse

2009-01-16T04:31:00.000-08:00

I was facing this issue in Eclipse Europa where the Spring configuration XML was not getting validated, when i included JBoss Cache related configuration in it. This is primarily because the Namespace and the Schema URI,

http://www.springmodules.org/schema/jboss
http://www.springmodules.org/schema/cache/springmodules-jboss.xsd

are not available at the respective locations, hence i guess these were not bundled in Eclipse Europa. I spent about 4-5 hours breaking my head on this issue before I found the solution in another blog.

The way to get your XML to be reported as validated is:

1. In Eclipse, Click on Window > Preferences.. > Web and XML > XML Catalog

2. Under XML Catalog, Click on User Specified Entries and then click on Add...

3. Create the following Entries/Locations

>>>>> [Replace pathto with the actual location of the JAR on your local machine.]

>>>>>> jar:file:pathto/spring-modules-cache.jar!/org/springmodules/cache/config/springmodules-cache.xsd

>>>>>> KEY TYPE Schema Location

>>>>>> KEY http://www.springmodules.org/schema/cache/springmodules-cache.xsd

>>>>> jar:file:pathto/spring-modules-cache.jar!/org/springmodules/cache/config/jboss/springmodules-jboss.xsd
>>>>> KEY TYPE Schema Location
>>>>> KEY http://www.springmodules.org/schema/cache/springmodules-jboss.xsd

4. Refresh the XML file in the Project Explorer and... all XML validation errors have gone!

Spring, Hibernate, EhCache Recipe

2009-01-15T04:56:00.000-08:00

A simple scenario explaining the usage and performance, when using EhCache along with Hibernate in a Spring environment. The performance results are taken using mySQL as the database. I started off my experiment with JBossCache, but had one hell of a time with it's configuration within Spring. [Download Sample Code]

In this example, I need to retrieve close to 5,000 records in a single fetch and then cache this information. As usual, setup Spring contexts in your Spring configuration file. I have just one bean, which is a Hibernate DAO, HibernateDoctorDAO.java. The dependency injection hierarchy is dataSource > sessionFactory > hibernateTemplate. hibernateTemplate is then injected into the HibernateDoctorDAO.java at runtime by the Spring Framework.

The implementations of each of these are:

dataSource > org.apache.commons.dbcp.BasicDataSource

sessionFactory > org.springframework.orm.hibernate3.LocalSessionFactoryBean

hibernateTemplate > org.springframework.orm.hibernate3.HibernateTemplate

The results clearly shows the difference in performance with EhCache enabled, even in this simple example:
PERFORMANCE COMPARISON (in seconds)
==================================
QUERY FETCH TIME (INITIAL): 0.599
QUERY FETCH TIME (HIBERNATE CACHE): 0.212
QUERY FETCH TIME (2ND LEVEL CACHE): 0.091

The main program to run the sample is SpringOrmIntegration.java

Version Reference > Spring-2.5, Hibernate-3.0, EhCache-1.4, mySQL-5.0

Thoughtworks - A Different Company!

2009-01-07T20:17:00.001-08:00

It might be an inappropriate entry for this blog - sharing an interview experience. But one that might help people the most [ :-) ] especially when it is about... ThoughtWorks!

The company has a very interesting interview process, different than most i have come across, which speaks a lot of the company culture and the work that you might do there. I write this from the perspecive of an interviewee who participated in the interview process there, twice!

1. It all starts with an online application [Unless you are the lucky one whose CV has been sourced!]

2. Once shortlisted, you get a call from the HR who checks your comfort submitting code and explains the interview process.

3. You get two problem statements by mail, and have the choice of submitting solution for either of them - focus is on object oriented design [Mars Rovers problem should be famous by now]

4. Next I had a Phone screen, in which i was presented with a problem again for which one has to design and implement a solution - again object oriented skills are the focus. During the course, you might be presented with a change in requirement and have to explain how easily your design can adapt to these changes.

5. When i was interviewed the first time, the next round was in-office and I had logical and reasoning ability tests - which are really a breeze.

6. The first time I did not want to proceed beyond this point due to some personal reasons... The second time around I wasn't selected [ :-) ], But what I know is that the subsequent interviews focus on how well you can code pair with other Thoughtworkers and a series of technical interviews on your primary technology skill.

7. The offer, I am sure once in you would never want to be out - working with the best technical minds....

What I love about this process, as a developer, is that unlike other interview it tests and validates all your abilities in real-time [technology knowledge, problem solving, design skills, implementation skills and most of all that you can code - no matter whether you are an architect, tech lead or a senior developer]. The other important aspects that I like [and have read or heard] about the company is the flat hierarchy, enterpreneurial culture, agile process and that it values technology.

Design Patterns - Series II

2008-12-05T04:18:00.000-08:00

My concluding write-up on design patterns, with some examples.

Adapter Pattern [Sample Code]
What can one do if he needs to use an Asian Hairdryer in a European Country, each with different socket types? I would seek an Adapter! As in real life, when we want to plug and play with similar but incompatible interfaces we use the Adapter. The Adapter adapts the Adaptee to the desired interface, by composing the Adaptee object and inheriting the desired interface or by multiple inheritance.

The attached example is a real world Computer scenario, where I want to plug in an external hard drive (pre-usb era!), SeagateDrive of interface type SeagateGeneric to an incompatible computer, SamsungComputer of type Computer. SeagateGeneric provides read() and write() methods for the specified purposes, which needs to be adapted to the actual bufferData(), flushData() and purgeData() methods of the Computer. Note that there is no equivalent of purgeData(). The ideal way to handle this scenario is to throw an exception, whenever this method is invoked on the hard drive as it would do in the real world. The adapter to perform the translation in this scenario is the SeagateAdapter, which implements the Computer interface. It encapsulates a SeagateGeneric instance reference, and adapts it to the Computer interface. Whenever a bufferData() method is invoked on the Computer interface, it actual requires three invocations of read() on the SeagateGeneric implementation to match up to the Computer’s standards. These kinds of translations are done by the adapte.

PCAssembler is the main class here. Try adding your own device and its adapter to the computer.

Facade Pattern [Sample Code]
Consider a scenario where we require multiple method invocations on various classes, to achieve the desired functionality. Also, consider that this set of functionality is repeatedly being used in your code. If you are thinking of an option where you will perform direct invocations, you are bound to end up with code maintenance issues and tightly coupled code. If these invocations are remote, it is going to be worse with respect to the performance. This is where the facade comes into play, wherein multiple method invocations are encapsulated into a single method of the facade class, to achieve the desired functionality. It provides us with a single point of change and looser coupling, with respect to the individual implementations. Remote method invocation patterns like SessionFacade (EJB) adapt from here to improve the overall performance and lower complexity.

The example attached is a very simple scenario of a InvoiceManagerFacade which has addInvoice() and deleteInvoice() methods. To achieve the desired result, each of these methods encapsulates the method invocations from OrderManager, LedgerManager and BillingManager classes.

AccountsCentral is the main class. Try adding your own method to the facade class, or try plugging in a new type of facade.

Template Pattern [Sample Code]
Imagine a real-world scenario where a factory is creating both aluminium nails and screws. Though the machine has to create both of them through similar processes, the way some steps are implemented may vary in each of these. When we think of such scenarios in software, we utilize the template pattern. Template pattern defines a way to re-use algorithms for various implementations with different or slightly different outcomes.

In the attached example, the abstract class SoftwareProcessor defines a general set of algorithmic steps (functions) to deliverSoftware(). This class is my template class. Since the implementation and testing phases differ in projects based on the technology stack being used, CProcessor and JavaProcessor classes adapt this algorithm for these phases. The common methods are all implemented in SoftwareProcessor and the specific ones are left as abstract.

SoftwareConsultants can be used to run this example. Try adding your own processor.

Iterator Pattern [Sample Code]
The need to have a handle to a collection of elements, without exposing its internal implementation is met by the Iterator Pattern. I would term this as a pure programming pattern, in its own right. By utilising this handle (Iterator), the client using the collection can easily process the same without any dependency on the internal logic.

In the attached example, ProductMenu holds a menu or list of ProductItem. This list and its usage should be implementation agnostic to the clients. Hence, the need for a ProductIterator which implements the generic Iterator interface. The createIterator() method of ProductMenu, passes the array implementation of ProductItem to the constructor of ProductIterator.

The example can be run using ProductMenuTester.

State Pattern [Sample Code]
State Pattern defines a way to maintain various steps or states of the same machine or class. The word machine comes to the mind easily, because it is the simplest example of a real-world scenario where there is a need for operating the same object in steps or set states, with the transition from one step to the next defined by a single action (or multiple actions).

The example attached is a very crude but helpful one, that of an OnlineShopping site. The limitation of the site being that at any given point only a single item can be purchased and processed. The various states during the purchase and processing are SelectionState, PurchaseState, AuthoriseState, AssembleState (optional) and DispatchState. Each of these states is processed and followed in a sequential manner. OnlineShopping maintains an instance variable of each of these states and also a currentState variable. The various state methods that exist within OnlineShopping are selection(), purchase(), authorise(), assemble() and dispatch(). When client calls these methods, the actual invocations are performed on the state implementation held in the currentState variable. All state implementations implement the State interface, which specifies the lifecycle methods.

ShoppingClient is the main class. Try adding your own states along with the required lifecycle method.

Design Patterns - Series I

2008-11-30T21:30:00.000-08:00

Was going through the book ‘Head First Design Patterns’, came up with my own examples to understand them further. Try downloading the code and see if it helps you in comprehending these in a better way.

Observer Pattern [Sample Code]
Observer Pattern, as the name suggests, is used in scenarios when updates need to be done at multiple points (Observers) depending on changes in state at another place (Subject). Each of the Observers has to register themselves with the Subject, individually. The Subject should also provide method which allows the Observers to remove themselves. Registered Observers are informed of changes in state through a notify method, usually.

The provided example is that of a StockBroker application, which involves maintenance of various types of financial information. Subject is the interface in the application which provides a template for the Observed class. StockData is the concrete implementation of Subject and provided implementation of addObserver(), removeObserver() and notifyObservers(). Additionally, it maintains a list of registered observers. IncomeHandler, InvestmentHandler and PortfolioHandler are the various observers used to maintain income, investment and portfolio of a specific StockBroker. All these depend on the constantly fluctuating values of stocks. They are specifically interested in the stockSymbol, stockValue and stockUnits of each individual stock. Each of the observers implements the interface Observer. The Observer interface provide the update() method, which is implemented by each of these concrete classes.

Use StockBroker.java to run the application, Try adding your own observer to this application. Also, you can try picking up these values from a live web service and then writing a custom observer which depends on this.

Decorator Pattern [Sample Code]
Decorator Pattern provides an elegant way to use composition for enhancing functionality, where the result expected has direct dependency on the composed and composing class. A chain relation (via composition) or decoration can be finally used to achieve the desired output at runtime. In real-time, when the functionality of one particular product is expected to be built form a base product and various other related sub-products or fixtures, we can rely on the Decorator.

The attached example is that of a Pizza application. Here, the pizzas in the shop are made with various combinations of bases and topping combinations. This is a classical example for usage of the decorator pattern. Pizza is the abstract base class for each of the pizza bases to implement and ToppingDecorator is another abstract class that inherits from Pizza for each of the toppings to implement. Hawaiian, Italian and Mexican are the concrete implementation of Pizza whereas Mushroom, Onion and Chicken are the concrete implementations of ToppingDecorator. Each of these toppings encapsulates a Pizza instance. This instance, at runtime, will hold another topping or the pizza base instance. Finally, it is when the cost has to be calculated on the entire pizza that the real value of decorator pattern is seen and just one call suffices to calculate the entire bill value.

PizzaWorld is the main class. Try adding more decorators and pizza base classes to see if you can get a real taste of the Decorator!

Singleton Pattern
Singleton Pattern defines a way to maintain only single instance of a class in the entire execution of a program/application and to provide a uniform way to access it. There are numerous methods which exist in which this pattern can be implemented. I have explained three most common scenarios here:

1. Eager Singleton [Sample Code]
The simplest singleton is the one in which the instance is created at class-load time, and stored in a static instance variable. A static getter method is then used to get this instance, when required. The instantiation of an object earlier than its first use might not be a recommended approach.

In the given example, MediaContract (Main Thread) works on an instance of the ProductionHouse (Singleton). The Singleton is instantiated at class-load time and maintained in the private static instance variable. getInstance() in ProductionHouse helps in retrieving the instance.

2. Thread-Safe Singleton (Most Common) [Sample Code]
To overcome the above drawback, the recommended approach is to instantiate the object at the first access time and also to make it thread-safe to prevent concurrent thread instantiation. The disadvantage of this method is poorer performance, as the method is synchronized.

As in the earlier example, the classes are MediaContract (Main Thread) and ProductionHouse (Singleton). getInstance() method is synchronized and the instance is created only if it is null.

3. Double-checked Locking [Sample Code]
The disadvantage mentioned above can be critical for a highly accessed object in an application. To better this, the scope of the synchronized block is reduced to affect only the first access. This again has some disadvantages. I recommend reading on Initialization on Demand Holder Idiom.

The example remains the same, the difference being in the reduced scope of synchronisation within the getInstance() method and also that it affects only the first access and not subsequent accesses.

Command Pattern [Sample Code]
In scenarios, where we need to create a sequence of actions (or operations) and perform them at a specified (later) point in time, we have a candidate for usage of Command Pattern. Though it very closely resembles the Observer pattern in implementation, the usage is different and the command (actions) is invoked only on a single chosen receiver by an invoker, than on all observers.

The example is of an Auction House where there are various items for auction, the base abstract class of which is represented by AuctionItem. The abstract method to be implemented by implementing classes is sell(). AuctionVase, AuctionFurniture and AuctionJewel are all concrete implementations of AuctionItem. Instances of each of these are created and set (mapped by an itemKey) into the AuctionControl, which can be thought of as a remote control for presenting items in the AuctionStore. Whenever the presentItem() is invoked on the AuctionControl class, passing in an itemKey, the appropriate AuctionItem instance is selected and sell() is invoked on this instance.

Factory Pattern
Factory Pattern, I am made to believe, is the most widely used and implemented pattern in software projects after the Singleton Pattern. Since Singleton is only a creational pattern at single class level, the scale of the effect of usage of Factory should be much higher. Factory Pattern deals with creation of similar type of objects and production in a centralized manner, depending on the condition or type of object requested. There are variations of the usage of factory pattern, three of which I have enlisted below:

1. Simple Factory [Sample Code]
The simplest factory is the one that is used to create (instantiate) a specific type of product (object) depending on a condition. The specific types of objects that can be created in a single factory are all expected to implement a single interface.

In the attached example, the factory is used to instantiate a specific type of object depending on the operating system. All the specific systems implement the System interface, which defines the common methods that the concrete class of this type should implement. SystemFactory is the factory class which provides the create() method which takes a type argument. The type argument decides which concrete factory should be instantiated.

2. Factory Method [Sample Code]
When there can be various families of products (objects) that which can be instantiated, but each family of these product needs to be created by a specific type of factory, we define a factory method in the base factory class. The concrete implementations of the base factory then override this method to produce concrete type of products, depending on the condition.

In the example, you can notice the presence of two abstract classes, Mobile (Product) and MobileStore (Creator). One family of concrete product implementations are NokiaASeries, NokiaBSeries and NokiaCSeries to be created by the NokiaStore, which is the concrete implementation of the creator. In similar fashion another family of products such as SonyASeries, SonyBSeries and SonyCSeries are to be created by SonyStore, another concrete implementation of MobileStore. MobileStoreCentre is the main class to run this application. The createMobile() method is the abstract method (factory method) that is to be overridden by the creator implementations.

3. Abstract Factory [Sample Code]
AbstractFactory defines a template or interface for creation of similar types of objects or implementations. Usually, AbstractFactory will encapsulate a factory method or more within for actual creation of the product.

Taking the same example as above, MobileAutoMechanic provides an interface for creation of similar types of mobile auto mechanics. SonyAutoMechanic and NokiaAutoMechanic provide the necessary implementations. Each of the product classes now starts taking the auto mechanic instance of their own type of family, in the constructor. Each of these mechanics has the knowhow of the pre-assembly steps and performs the same.

EJB v3 Client for JBoss Gotcha!

2008-10-26T09:56:00.000-07:00

If you are writing a standalone client for either a local or remotely deployed EJB v3, and face the following issue:

javax.naming.CommunicationException
[Root exception is java.lang.ClassNotFoundException: org.jboss.ejb3.proxy.JBossProxy
(no security manager: RMI class loader disabled)]
at org.jnp.interfaces.NamingContext.lookup(NamingContext.java:788)
at org.jnp.interfaces.NamingContext.lookup(NamingContext.java:629)
at javax.naming.InitialContext.lookup(Unknown Source)
...

The simple fix is to include 'jbossall-client.jar' in the client classpath.

EJB v3 Buy-In

2008-10-21T16:10:00.000-07:00

Studying for my SCBCD 5 certification, I noticed these differences between the EJB v3 specification and Spring v2 framework. Thought i should share these. I will add the performance results as well, once i have something substantial.

In Favour of EJB v3,
Easier implementation for web services
Time tested & Robust method for Remote Access
Better instance pooling mechanisms
Stateful session beans
Annotations make it easier
JEE Standard / Sun Support / Industry Affiliation
Wide App Server Feature Support

In Favour of Spring v2,
JDBCTemplate and JMSTemplate
DI even for POJO (outside container)
AOP is feature-rich (but complex)

And no... I do not sell for Sun.

Techila Shots!

2008-08-29T02:12:00.001-07:00

Well, that's a catchy name... you'd be thinking. This wasn't a very well thought out title or one that required a christening ceremony. Had it in my mind for a few years, tried implementing it in an organisation as well. So, What is Techila Shots?

Techila Shots is a measure of techie talk delivered with a dash of passion and a slice of experience, that gives a kick to my developer psyche (What a Pitch?). It is a forum that presents my thoughts on technical topics that i am most enthusiastic about. Mostly, It is about the geek in me. Hope that someone reading it will find it atleast helpful, if not as much to deliver a kick!