Java developers prepare for upcoming trends in software industry!

The Only Thing That Is Constant Is Change”

Like everything else ecosystem around java professional is also changing and from what I gather future holds bigger changes then we are used to. Experts and veterans are already debating if java is dying, some feel that Java has reached its peak and nothing major can be done with its present language core. Only time will tell what future of java is going to be, but consensus is that whether or not java survives, JVM is here to stay i.e. dominant language of the future will have to support JVM. I personally feel that java is not going anywhere soon and may still be one of dominant language for years to come. In any case java professionals should be aware of uncertainty that java as a language faces in future and should prepare accordingly.

Learn Functional Language

As you may have already observed processors have stopped getting faster, and the number of cores available in a CPU are growing rapidly. In order to utilize a multi core processor, the operating system must be able to recognize multi-threading and the software must have simultaneous multi-threading technology (SMT) written into its code. SMT enables parallel multi-threading wherein the cores are served multi-threaded instructions in parallel. Without SMT the software will only recognize one core so  an average user with multi-core processor will notice the difference in performance if software is SMT aware. So bottom line is that we need to build concurrent software’s to make best use of hardware available to us.

Compilers can’t automatically parallelize imperative/object-oriented code, so programming styles have to change. Algorithmically simple concurrency can be achieved using libraries and extensions to existing languages. For example we can use the concurrent package in Java. But building complex, fine-grained concurrent systems quickly runs into a complexity wall in languages like Java. The answer is functional programming, functional languages like Erlang, Haskell and Scala offer better support for concurrency with features  like actor concurrency, software transactional memory and nested data parallelism. So learn a functional programming language. As a Java programmer, the easiest way to go is learning Scala. Parallelization is going to be huge and knowing how to write scalable and maintainable code for parallel systems will be a big plus.

Follow the Cloud

Another trend that has already gained a level of momentum is Cloud computing. Cloud computing that way I understand it is a virtualized, self monitoring, self healing and automatically configured network of computers managed with awareness of the user load and service level required for each of the applications deployed on it. As the load on an application increases more resources are allocated to it automatically from the network to maintain the service level. As the load decreases the resources are de-allocated automatically. Considering that applications deployed on the network will have different peak times, instead of allocating dedicated hardware to each of the application we can have a shared virtualized hardware infrastructure which translates into cost saving.  This network of computers is called a cloud because users and applications running on the network will not have the awareness of the physical hardware being used to service the request at a given point of time, so from this point of view the network is essentially a cloud of similar machines processing requests. The word “cloud” emphasizes the thinking which considers the whole network as a unit rather than a collection of units or machines.

Cloud development paradigms like distributed computing and scalability are not new to java, synergy between java and cloud computing is evident.  Java EE was designed to be deployed to a distributed environment. Cluster management and extensive monitoring and management capabilities are supported by major application servers. Most of the technological changes for supporting the cloud are focused at a system level and it’s largely unclear how exactly to prepare for this as a java professional, but be sure to watch trends carefully and study accordingly. One emergent impact of cloud is the implementation of persistence services. Some cloud providers, like Google or Amazon, don’t offer support for relational databases. So you either have to live with the map-like structure or try to install a relational database in the cloud. This necessitates some rethinking about how the persistence should be designed and can even impact the design of the user interface.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s