Relax, have fun and Play.. er Learn

Relax Play and Learn is the new mantra.. at least in learning Rails and related web tools used for development.
Maybe its just me, but over the past few days, I am increasingly finding newer and diverse forms of learning web development, especially using advanced frameworks like rails.
Some of these are directed at learning inter-spread with videos that users can learn at their own pace like the rails for zombies and others that focus on user provided content created by users themselves. Then, there are language specific courses like http://www.rubylearning.com .
When I started learning rails, how much I wish that I had access to similar resources as these are godsend for learners; they serve the dual purpose of ease in learning as well as enjoyment for beginners.
As I write this post, I am also casually looking at various websites like peepcode.com that offer much higher quality screen casts than railscasts.com especially for beginners.
What is surprising is that other technologies do not have this type of support, but web application development centered around rails, scripting languages and HTML5, CSS3 and jQuery combined are increasingly finding this support. One can only hope that this type of open and user friendly learning increases its umbrella and allows more technologies into its fold in the near future.

So If you are a beginner or are considering using rails, my humble advice to you is to bookmark these and start when you have some extra/free time.

Book Review: Play framework cookbook

I had recently a chance to review the book, 'Play Framework Cookbook' by Alexander Reelsen through Packt Publishing.
Born out of inefficiencies in the workflow of conventional Enterprise Java development, Play framework has arisen and although has not reached great heights like its inspiration, Rails but has made name for itself and in turn has inspired various automation and rapid application development tools in java.
Out of a cookbook, you'd expect some power packed stuff backed by easily repeatable examples. This book does the same, even though the exercises are not that inspiring or usable but this is largely a framework issue.
The book starts with installation and runs the user through a newly created application. Next, controllers and features like authentication and rendering are discussed followed by modules. Although the book does not exhaustively lists modules, but provides fair amounts of module usage - being a cookbook, it can contain only a certain amount of module recepies at a time.
A nice feature that I'd like to point is the inclusion of creation of new modules, something which I didn't see before on other cookbooks.
Finally, the book caps off with production/deployment related chapter which is also highly appreciated as the other stuff is already there on documentation and other texts.
As java web development is scattered, on few places, even while following the book, I felt lost and could not comprehend the flow of the program. Also if the code was provided on github, things could have been easier, but that's just me.
As the book author states, It is for people with development experience and a bit of play framework knowledge/comfortableness, the book indeed does justice to its name.
Disclaimer: I received the copy of the book for review via Packt Publishing, if you feel like browsing this, head over to https://www.packtpub.com/learning-play-framework-2/book.

Book Review: Jump start sinatra

The book is a good starting point for a new as well as intermediate experts having background in developing web applications in ruby.
However, this book assumes a basic level of competency in developing web applications as it is obvious from the very less emphasis placed for discussing over concepts like git, css, javascript and html. Since it assumes that a user knows ruby and has a basic idea if not familiarity with Ruby On Rails, rather than repeating basic information all over again, the focus is more on latest tools such as heroku, sass, coffescript that are more complex, but are more relevant if seen from a point of an intermediate or professional developer.

The book is centered around end to end application development of a sample website and lays emphasis on adding new features over it during the course of different iterations as is done in real life.
Considerable mentions go to deploying the website over Heroku as well as introduction of DataMapper  ORM.
While this incremental approach of building a sinatra powered application makes perfect learning for beginners, lack of pointers related to advanced solutions, tackling issues like setting up environment, debugging, etc are felt as the books usability seems constrained by the simplistic pattern it adopts.

After a high level introduction, a basic website is created, using different views. Next, a basic CRUD functionality with database is exposed and the application is deployed live, this is followed by additional DRY concepts available in sinatra and the book caps off its learning with creating modular sinatra applications and enhancing its functionality by demonstrating a custom framework.

Overall, this is a 150 page neat  and to the point book for people interested in sinatra.

Note: This book has been provided to me for reviewing under the Oreilly Blogger Review Program.

Demystifying DevOps

There has been a lot of noise recently about this 'DevOps' movement. In this blogpost, I present my take on the topic and hopefully, help the reader towards understanding it.

Wikipedia puts this as:
 "DevOps (a portmanteau of development and operations) is a software development method that stresses communication, collaboration and integration between software developers and information technology (IT) professionals."

Image: Wikimedia Commons

However, owing to pressures often within large corporations having plentiful resources at their disposal, it is easy to create a hype around a process that in general, is common sense and at the very best is automation.
Speaking of agile delivery, it is easy to deliver a product in small teams that the big ones. As my experiences go, in my present company the product gets a new release every evening(India time), prior to which the changes made in the release are tested by the commiters of the changes itself before the decision about build is taken. After the release is done, basic testing as well as testing of the new features is carried out. While this is pain staking methodology, this works well as the team size is relatively less, leading to fewer overall changes. As an astute reader would have pointed out by now, what is missing is automation as well as demonstration of scalability - about what to do when the product goes live. Some uneasy questions like these are answered by the DevOps which:

• Focuses on convergence of Development and Operations.
• Minimizes the gulf/barrier between development and production.
• Brings about QA into development.
• Is agile, and strives the processes after development to be agile/flexible
• Required as rapid scaling & uptime of applications is necessary.
• Focus on automation, towards reducing repetitive work

So, where does a software developer like me comes in?
Here's what I typically deal while playing with web applications: Java, ruby and some combination of these thrown in together with the odd php or python based applications. In this recession prone economy, there is a requirement for cutting costs; which can be effectively met by ensuring that developers also stick in charge for the deployment process. As this lean process gains its acceptance, it is obvious that development is going to be easier for operations people and similarly for developers, deployment/production environment is going to reduce its level of complexity.

Where does it affects us ?

For the java developers, the heavy duty work gets 'magically' done by the enterprise servers that we deploy on. As java is built with performance in mind, it is easy to ramp up the scale of operations (tomcat is insufficient, deploy on glassfish, Too many queries, use memcached, database connections are piling, use connection pooling).
However, the (physical) servers over which these applications are deployed in production also need to be profiled and studied.

To run load/stress tests, one needs to have a production environment. These are easily available as Amazon Machine Instances or rackspace or any other myriad cloudproviders, however this costs money and given the increasing hardware capabilities, one can perform similar tasks without using the cloud(and paying for such kinds of testing).

Virtualbox needs no introduction and is a free virtulization tool from Oracle (it was a sun offering earlier). However, for our example, even virtualbox fails out of box as it can only provision a single vm. To enhance its capability, one can use Vagrant, which is a tool for building and distributing virtual development environments. In other words, it is what rvm is for ruby; a manager that lets the user have clean state (of the server) as well as abstracted setup(different server configurations from same set of VMs). Vagrant is primarily a driver for virtualbox vms.

One can work with it on a per-project basis(similar to a version control) and configure it through a plaintext file, Vagrantfile which vagrant uses as a DSL. The nicest thing about it is that it does everything that you need virtualbox UI for, which is really beneficial while running numerous headless servers.
For example:

Vagrant::Config.run do |config|

   config.vm.define :app do|app_serv_config|

     app_serv_config.vm.customize ["modifyvm", :id, "--name", "app", "--memory", "512"]

   end

   config.vm.define :app2 do|app_serv_config|

     app_serv_config.vm.customize ["modifyvm", :id, "--name", "app2", "--memory", "512"]

   end

   config.vm.define :db do|db_config|

     app_serv_config.vm.customize ["modifyvm", :id, "--name", "db", "--memory", "1024"]

   end 
end

This is just getting started with different servers as in real life, you'd need to provision the vms - setup them with useful stuff and services, deploy and run your programs on them. Two of the widely popular tools that deserve a mention are: puppet and chef.
While the documentation and discussions around them typically involve rails, there is no reason why java, and for that matter any other technology stack can not be used.
Puppet helps us chiefly with setting up the stuff; it is not big on automation, but saves us the work of setting up different softwares in a vm manually.
For instance, the following puppet config file sets up apache and ensures that it runs as a service during vm startup:

Exec {

  path => "usr/local/sbin:/usr/local/bin:/bin:/opt:/usr/sbin"

}

package {

  "apache2":

      ensure => present

}

service {

    "apache2"

         ensure => true,

         enable => true

}

Once we've set up our environment, only half of the battle is over as we also need to monitor and report the status of the environment to evaluate the areas of concern in the setup.
Nagios is a wonderful monitoring tool that displays the health of server - which is needed in a headless environment. To use it, we need to build a puppet module and  enable its service and use the nagios server interface on the vm itself to gleam the details of the vm, displayed as services  as well as re-shedule it when needed. To monitor the nagios instance itself, one can use a service like pingdom.

There are various other tools related with setting up of the servers, but would stretch the discussion far from the concept of devopts in practice. Thus, there is a need to resist the urge of going on to cloud, but keep the production environment close to the development environment itself. This would not result in the elimination of cloud as production environments are now predominantly becoming cloud based, but will go a long way in ensuring lesser pains when the product goes 'live'.

Exporting java projects from netbeans to eclipse

Yesterday, I had to create a simple java desktop application for performing some file based automation quickly. For this I used Netbeans that has Mattise RAD tool inbuilt(it is available for eclipse also, since it is rarely required, I haven't installed it there) to create a desktop java application that I intended to export as a standalone jar file.
However the finished jar file could not run anywhere else as it did not package the referenced libraries in itself.

Exporting a runnable java application from Netbeans does not works out of box, as you need to export the entire dist folder that contains the distributable .jar file as well as the lib folder containing the dependant jars. In order to do so, I devised the following method that saved me a lot of time.

1. First, create an application in Netbeans and build it.
2. Open eclipse and create an empty java project.
3. Copy the source folder contents to create the equivalent project in eclipse.
4. Copy the jars and set the build path to fix the compile errors occured by missing reference.
5. Check whether the exported project works in eclipse.
6. Finally export the eclipse application as a runnable jar.

There are other methods ; i.e: Changing the jar file manifest, copying the referenced jar contents into the final jar, but these are more error-prone than this one.