My Little Take on Backend Development

Update 29-10-2012:
I found this blog post more comprehensively in defense of Java EE 6.
Original post:
This comes from someone who only just recently read about JTA and JTS. Take this with a grain of salt, so to speak.

I have some experience using the Spring Framework, mainly the Spring MVC sometime about 2years ago, and some again just recently (as indicated in my previous post).  Back then, it was first a multifinancing application, second a message broadcasting engine, sort of.  Neither of which I created from the ground up.  I was merely adding features and so on.  I couldn't compare it against the Java EE 6 at that time, lack of understanding of their internals and so on.

The message broadcasting engine had to be improved so that it could support more load.  There were topics such as clustering, high availability, parallelism, concurrency, etc.  I think it was then that I came across the JMS and some asynchronous processing features provided by the EJB 3.  That was to be my gateway to Java EE 6.   Afterwards it was a haphazard series of choice to learn the actor model, CSP, Scala, Erlang, Haskell, NoSQL, etc.

So I wonder what was it again, Spring Framework's winning points.  Their documentation is among the best.  Their framework itself is rock solid, for what it is.  What it is, really, is a little confusing, though.  It appears to be sort of an alternative to the Java EE stack, but heavily relies on it.  It manages the object lifecycles.  Java EE does that as well, manage object lifecycles.  Two things manage your object lifecycles.  Obviously you can run Spring Framework on a standard servlet container, but I see everywhere that it is recommended that you use, say, the JTA provided by the container when available.  It would be unavoidable that both containers will manage the object lifecycles if you used CMT alongside Spring.  And how is it that one could share a bean across deployments in Spring?  Even if you could, I think using Spring remoting, your object lifecycles management would be more complicated because it would be a communication between two unrelated containers.  It looks to me that the EJB specification is superior in this regard, with its local and remote beans concept and tighter integration with JTA and the rest of the Java EE specification.

Anyway, honestly I'm not a big fan of dependency injection, Spring or CDI.  It's a little too much magic for me.  Language level singleton object construction available in Scala and programmatic lookup and vending are easier to work with.

Integrating Spring Framework, Jetty, and JBoss Narayana

Update 29-10-2012:
This does not work. I posted this only after testing rollback in a transaction, and it worked. However, I couldn't get it to work as Hibernate's transaction manager alongside Spring; e.g. update operations miss the transaction scope. I tried many setup variations. If someone manages to get this working, it'd be great if you shared. For the time being I'm falling back to CMT provided by JBoss AS.
Original post:
I had to browse through quite many websites and tested some adaptations to eventually get this to work. Shame on me, it's not all that complex how it ends up.
Oh, and my syntax highlighter does this XML tag uppercase thing that is so uncalled for.
My stack goes as following:

• Spring Framework 3.1.2.RELEASE
• JBoss Narayana 4.17.1.Final
• Apache Derby (network) DB 10.9.1.0
• Jetty 8.1.7.v20120910

The Spring Framework of this version doesn't even need persistence.xml to be present, so configuration, linking data source, persistence unit, and transaction manager, in a single Spring context XML is possible and makes more sense.  The JBoss Narayana JTA guide shows that to incorporate JDBC connections within itself:

1. Use the com.arjuna.ats.jdbc.TransactionalDriver that comes with the Narayana library
2. Wrap a javax.sql.XADataSource by creating an implementation class of com.arjuna.ats.internal.jdbc.DynamicClass and bind the data source to a JNDI (programmatically).
   The TransactionalDriver will use the DynamicClass as its data source provider.

I stumbled at binding.  Admittedly I'm not quite sure how it works on Jetty.  I managed to make it work by, firstly, bind the XADataSource to JNDI using Jetty's context configuration. Here's how it looks like in my jetty-env.xml.

 
 jdbc/dbxa
 
  
   mydb
   username
   password
  
 

Secondly, I let my implementation of DynamicClass, in its concrete getDataSource(dbName:String):XADataSource method to perform JNDI lookup, cast it to XADataSource, and return it. Simple as that. Why did I even bother struggling with Spring JNDI binding and JMX and whatever else. Here's how it looks like:

public XADataSource getDataSource(String dbName, boolean create)
  throws SQLException {
 try {
  InitialContext ic = new InitialContext();
  ClientXADataSource40 xa = (ClientXADataSource40) ic
    .lookup("jdbc/dbxa");
  return xa;
 } catch (NamingException e) {
  throw new SQLException(null, e);
 }
}

Afterwards, I bind things together in the Spring context XML.
Since I already defined the credentials in the Jetty context configuration, I don't need to repeat it here. The driver properties bean is just:

 
  
   my.implementation.of.DynamicClass
  
 

Next is the data source bean. I have to prepend the JNDI with jdbc:arjuna:, that's just how it works.

 
  com.arjuna.ats.jdbc.TransactionalDriver
 
 
 
  
 

And then the EntityManagerFactory bean, which also replaces persistence.xml. I happen to use Hibernate, so that's HibernateJpaVendorAdapter for me.

I also need to define the Narayana transaction manager and user transaction implementation beans as well as the Spring transaction manager bean itself.

And lastly if you like annotations:

As a bonus, you can also set where Narayana will store its objects, default timeout, etc by defining this factory bean.

 
 
 
  
   60
   .\arjuna
   .\arjuna
  
 

That's all. You can add a logger for com.arjuna.ats and set it to trace or fine to see whether it works. I don't suppose I need to show an example of how transactional annotation is used right. And there's that org.springframework.transaction.support.TransactionTemplate and org.springframework.transaction.interceptor.TransactionAspectSupport to allow manual, programmatic transaction control.

Lift Web Framework is Easy

It's ubiquituously said that the Lift web framework has a steep learning curve.  Hard to believe when

<div class="lift:surround?with=default;at=content" id="real_content">
 <h1>Welcome to your project!</h1>
 <lift:Hello.world />  
</div>

object Hello extends DispatchSnippet {
 val dispatch: DispatchIt = {
  case name => render(name) _
 }
 def render(name: String)(ignore: NodeSeq): NodeSeq = Text("Hello, " + name)
}

LiftRules.snippetDispatch.append {
 case "Hello" => id.openfx.openshop.snippet.Hello
}

simply wraps the page with the template 'default.html' and makes a snippet Hello.world lookup.

Everything in Lift is easy and transparent, I daresay. Most things can be reasoned as you write code, instead of having to read its specification. I can't quite describe it precisely, but I'll give it a shot anyway. Because Scala allows "mix in" of traits, there is, CMIIW, no hidden container-managed proxy code is needed. Let's compare this with CDI used in the JSF framework. To cater to different scopes, a CDI bean can be annotated with @RequestScoped, @SessionScoped, @ConversationScoped, etc. How does it look like when constructed? Honestly I don't know. I only know how it should work thanks to the CDI spec's documentation. But I think the container would have to create a specific proxy for each bean depending on its scope, and inject its proxy dependencies and so on. The proxy might also be different when you add @Stateful to, say, a @ConversationScoped bean.

On the other hand, in Lift, it's much simpler. Snippets are normal methods registered via the LiftRules object during boot. Request and session states are just plain objects extending either RequestVar or SessionVar, used directly by snippets. The separation between controller logic and session/request data is clear here. You know what's happening to your stuff by checking out what's inside what you're extending.

Here you don't know what's there

Quite some shift having worked mainly at companies that were open source-centric before, now at one that endorses proprietary enterprise platforms.

I have found that latter such companies don't recognize open source efforts and startup solutions.  It is a mystery (to them, at least) how Twitter has managed so far with obscure languages like Ruby and Scala.  It must be a joke to claim Google used commodity hardware for their servers.  When you have a USD 30K DBMS you have no reason to consider NoSQL toys.

Whereas at my previous workplaces we would probably be rolling our eyes, thinking why we would ever need it, when offered, say, a USD 30K DBMS when we ran everything on PostgreSQL just fine.  Yahoo! did it with PostgreSQL, why couldn't we, right?  We could implement Hadoop and Cassandra for specific tasks if they fit better than they would on PostgreSQL.  If everything were still slow, it would be the development team's fault, of course.  Couldn't have it any other way because, otherwise, why hire us at all.

But of course, experience will vary depending on how one makes use of either technology.  Many proprietary products do excel at what they do.  And it is only natural that people spend money on these works.   I'd think the distinction is that at one (extreme) end you see lots of money and at the other (extreme) end you feel a great deal of passion (and both are perhaps equally reliable catalysts of creativity).  This isn't a rant on merits of either practice--not that I have authority on that topic to begin with!

What this is about is how easily we turn a blind eye to the other side when we've been delving in just one side of the equation for long.

Around the Web

Sometime ago I checked out different approaches to web application development (in my free time.)  With Python I explored the Pyramid framework as well as Django.  With Scala I did Lift.  And lastly I explored JSF using Groovy as a replacement for Java.

Actually I was quite overwhelmed with Python.  It's not difficult to write anything in Python. 
However, to write good code in Python it should take considerably more effort and more thorough understanding of the language.  I stumbled across a lot of metaprogramming then.  I think it grossly difficult to feel secure because, with metaprogramming alongside dynamic typing, most of your application's survival depends on the condition of your gestalt.

Scala lifts much of that mental burden off me I should think.  I like Lift.  I could do more in Lift in the future.  :)

Groovy is, as I probably wrote in my previous post, somewhat in the middle when it comes to typing--a degree of static as well as dynamic typing.  It saves a lot of time and code lines.  In a way it intuitively guides me to write better code.  There can be a lot of metaprogramming too in Groovy, but it's not a show stopper.  You don't necessarily have to understand it to write good code.  Though it's pretty easy (I think compared to that in Python).  It would be much better if Java EE and relevant stuff were tailored to fit Groovy more.  And better IDE support.  And a way to filter exception stack traces (Seam Catch maybe?).

Huh, OpenJPA?

Purpose of this post is primarily to help add hype around OpenJPA (there is lack of hype, from community and Apache/OpenJPA all the same).

Contrary to the plain vanilla JPA implementation vibe the project site gives off, OpenJPA might actually have its own distinctive virtue.   A popular phrase among Haskellers perhaps, "do one thing, and do it well."

Configuration might be a little daunting at first because it takes a rather different approach from such that Hibernate and EclipseLink share.  But that aside it has worked well for me (after about two-weeks use for development purposes) and perhaps most importantly for me is that its documentation is awesome.  The content feels well-thought out.  It comes in the usual online help and PDF formats.  Haven't you ever stumbled across duplicate or outdated content somewhere in EclipseLink's wiki-style 'Documentation Center'?

On that note, actually Hibernate comes with similar documentation formats as well.  The difference is that with Hibernate documentation feels more like a long tutorial (a JBoss thing perhaps?) while with OpenJPA (an Apache thing perhaps?), documentation is more formal.

Anyway one nice feature I've recently found is a native UUID generator assignable via the usual GeneratedValue annotation.  Excerpt from the documentation:

OpenJPA also offers additional generator strategies for non-numeric fields, which you can access by setting strategy to AUTO (the default), and setting the generator string to:

• uuid-string: OpenJPA will generate a 128-bit type 1 UUID unique within the network, represented as a 16-character string. For more information on UUIDs, see the IETF UUID draft specification at: http://www.ics.uci.edu/~ejw/authoring/uuid-guid/
• uuid-hex: Same as uuid-string, but represents the type 1 UUID as a 32-character hexadecimal string.
• uuid-type4-string: OpenJPA will generate a 128-bit type 4 pseudo-random UUID, represented as a 16-character string. For more information on UUIDs, see the IETF UUID draft specification at: http://www.ics.uci.edu/~ejw/authoring/uuid-guid/
• uuid-type4-hex: Same as uuid-type4-string , but represents the type 4 UUID as a 32-character hexadecimal string.

These string constants are defined in org.apache.openjpa.persistence.Generator.

So there goes my preliminary hype around OpenJPA.

What's a programmer to do in Indonesia?

One question that often comes up during an interview, "What do you expect from working with X company?"  Considering that the question is often asked somewhere along the end of the interview I would think it's only casual chat.  But I'd know better.  So, what do you expect from working with X company?

Sometimes I would blurt out (especially after a rough interview) and say something like, "All of it--good salary, nice environment, awesome colleagues, successful products or services."  Or would you rather hear someone say, "I love programming so I would like to have a lot of challenges coming my way.  I get a kick out of torturing my soul day in and day out."

Basically what I'm trying to say is that, no, economic situations in Indonesia won't allow a regular programmer to ever become successful enough to live well.  I'm talking about the small salary, yes.  I'm also talking about high property rates, poorly distributed IT companies across Indonesia (they all flock in central Jakarta), and bad traffic.  So the rhetoric is why would anyone want to pursue this kind of career in Indonesia at all.

Here's some loose calculation.  With perhaps up to 10 years of experience, one might land a decent position in the management--one out of, what, 50 people?  Suppose one is a highly accomplished senior programmer then.  The standard salary, I think, for a senior programmer here is currently at maximum 15 million rupiahs with a standard threshold of 30% and few lucky ones reaching over 25 million rupiahs.  The question is how long will it take from the moment one starts receiving salary decent enough to save up (10 million say, at age 27) until he owns himself a decent house.  Consider one is lucky and steady, with 30% of salary to save, standard 10% annual increase (loosely considering inflation and GDP trend), for a house worth 600 million rupiahs it will take about 11 years until you can finally own it--which is doubtful because once you reach age 30 you become much less marketable in the programming field (in Jakarta).

It's the fault of frameworks I'd say.  There are so many frameworks to build your application upon that enable companies to only hire average fresh graduates and have it up and running.  Hardly any companies need you to be a guru at it.  Hardly any companies nowadays (in Indonesia) will require you to be adept with lexical analysis, Z notation, serialization mechanisms, or even kernel scheduling. Chances are along the way in the future more and more experts will find it very hard to land a job befitting their expertise.

So I would instead say, "I expect to leave--have someone to remind me to leave even, to leave the company the moment I save up enough to start my own business."