My professional life as of now

Like the other years, this year too has been a hectic one for me so far and building upon my existing skills, I've tried to contuniously improve myself as a human being and as a professional. My policy so far has been 'Kaizen', which is the Japanese word that literally means continuous improvement.
So far, the greatest improvement that I've made in the first quarter of the current year has not on the programming languages or frameworks, or for that matter, any software development practice, but on allied fields. Currently, I am working upon solving business problems via alternative means like ERP, CRM and CMS softwares practically.
As I write this blog post, alternatively, I am reading an excellent e-book titled 'Cases on Strategic Information System' that has been given to my entire class of Computer Applications by our Management Information Systems teacher. This contains 24 insightful case studies on the subject and although I have gone through a handful of them, they are really ponderable problems.
Apart from this management hogwash, rest is business as usual. At the core of my heart, I still have misgivings about management as an ethical study and am satisfied that I resisted the temptation to take a managerial course after doing my bachelors.
At my college, the brand value of Sumit Bisht (yes, that's me) continues to rise. During the past month, I have successfully conducted a technical hands-on lab and gave various presentations in front of the entire department. Apart from this, I have frustratingly and agonizingly tried to learn programming for business intelligence and reporting and am making some headway there too. Hopefully, this strategic initiative yields me rich returns in future.
That said, the software developer in me has not taken a sabbathical and thanks to the Google Summer Of Code 2010, I am actively involved in open source software development and even if my proposal is rejected, I would carry on in these exciting projects. This is the first time for me in this event and quite frankly, I am impressed with the amount of attention this activity has generated. I checked into a lot of projects and finally selected a couple of projects which were doable in my opinion with ease. Thus, this summer is going to be as promising and engaging as the last one.
Ciao for now

Programming Wisdom

Recently, I had the opportunity to read the book, '97 things every programmer should know' by Oreilly publications. Normally I do not read computer books from cover to cover, but this was different. The book had 97 two-page insights by some very experienced programmers and people who really knew the stuff. As I read each pearl of wisdom, it was an engaging experience as every page seemed to yield me with a new insight.

However, as there are some common best practices in our trade, there was some redundancy in the text as well. Nevertheless, it was a journey that is really appreciated like us newbies (without any actual experience). So, like an engaging novel, this book really is a treasure trove for best practitioners and average programmers alike.

This was similar to my previous experiences while reading expert advice. Last year, I had the opportunity to read Bruce Tate's 'Beyond Java'. However, this text differs from Tate's as it is more 'politically correct' and does'nt focusses on advices by a single person. What is also wonderful about this book is that it is platform and language independent and the advices that it offers regarding programming are certainly most talked about in the industry.

As a conclusion, I'd like to give a tribute to the authors as they were simply too wonderful in their explanations(rather than engaging in an obscure jargon) Hats off to them.

Here's the listing of the wisdom(drum-roll) given in this book

1.       Act with Prudence

2.       Apply Functional Programming Principles

3.       Ask, “What Would the User Do?” (You Are Not the User)

4.       Automate Your Coding Standard

5.       Beauty Is in Simplicity

6.       Before You Refactor

7.       Beware the Share

8.       The Boy Scout Rule

9.       Check Your Code First Before Looking to Blame Others

10.   Choose Your Tools with

11.   Code in the Language of the Domain

12.   Code Is Design

13.   Code Layout Matters

14.   Code Reviews

15.   Coding with Reason

16.   A Comment on Comments

17.   Comment Only What the Code Cannot Say

18.   Continuous Learning

19.   Convenience Is Not an -ility

20.   Deploy Early and Often

21.   Distinguish Business Exceptions from Technical

22.   Do Lots of Deliberate Practice

23.   Domain-Specific Languages

24.   Don’t Be Afraid to Break Things

25.   Don’t Be Cute with Your Test Data

26.   Don’t Ignore That Error!

27.   Don’t Just Learn the Language, Understand Its Culture

28.   Don’t Nail Your Program into the Upright Position

29.   Don’t Rely on “Magic Happens Here”

30.   Don’t Repeat Yourself

31.   Don’t Touch That Code!

32.   Encapsulate Behavior, Not Just State

33.   Floating-Point Numbers Aren’t Real

34.   Fulfill Your Ambitions with Open Source

35.   The Golden Rule of API Design

36.   The Guru Myth

37.   Hard Work Does Not Pay Off

38.   How to Use a Bug Tracker

39.   Improve Code by Removing It

40.   Install Me

41.   Interprocess Communication Affects Application Response Time

42.   Keep the Build Clean

43.   Know How to Use Command-Line Tools

44.   Know Well More Than Two Programming Languages

45.   Know Your IDE

46.   Know Your Limits

47.   Know Your Next Commit

48.   Large, Interconnected Data Belongs to a Database

49.   Learn Foreign Languages

50.   Learn to Estimate

51.   Learn to Say, “Hello, World”

52.   Let Your Project Speak for Itself

53.   The Linker Is Not a Magical Program

54.   The Longevity of Interim Solutions

55.   Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly

56.   Make the Invisible More Visible

57.   Message Passing Leads to Better Scalability in Parallel Systems

58.   A Message to the Future

59.   Missing Opportunities for Polymorphism

60.   News of the Weird: Testers Are Your Friends

61.   One Binary

62.   Only the Code Tells the Truth

63.   Own (and Refactor) the Build

64.   Pair Program and Feel the Flow

65.   Prefer Domain-Specific Types to Primitive Types

66.   Prevent Errors

67.   The Professional Programmer

68.   Put Everything Under Version Control

69.   Put the Mouse Down and Step Away from the Keyboard

70.   Read Code

71.   Read the Humanities

72.   Reinvent the Wheel Often

73.   Resist the Temptation of the Singleton Pattern

74.   The Road to Performance Is Littered with Dirty Code Bombs

75.   Simplicity Comes from Reduction

76.   The Single Responsibility Principle

77.   Start from Yes

78.   Step Back and Automate, Automate, Automate

79.   Take Advantage of Code Analysis Tools

80.   Test for Required Behavior, Not Incidental Behavior

81.   Test Precisely and Concretely

82.   Test While You Sleep (and over Weekends)

83.   Testing Is the Engineering Rigor of Software Development

84.   Thinking in States

85.   Two Heads Are Often Better Than One

86.   Two Wrongs Can Make a Right (and Are Difficult to Fix)

87.   Ubuntu Coding for Your Friends

88.   The Unix Tools Are Your Friends

89.   Use the Right Algorithm and Data Structure

90.   Verbose Logging Will Disturb Your Sleep

91.   WET Dilutes Performance Bottlenecks

92.   When Programmers and Testers Collaborate

93.   Write Code As If You Had to Support It for the Rest of Your Life

94.   Write Small Functions Using Examples

95.   Write Tests for People

96.   You Gotta Care About the Code

97.   Your Customers Do Not Mean What They Say

It’s not that great Idea, Sirji!

This post is regarding the false nature of so called green IT revolution created by the media. To a large extent, adoption of technology has helped us save the pollution of earth, but are e-devices really giving us benefit that is promised against the regular ways. This Interview with Don Carli Executive Vice President of SustainCommWorld LLC, and Senior Research Fellow with the Institute for Sustainable Communication addresses some of the false claims made by e-reader companies.

Although the penetration of such devices is not much in our country, it is just a matter of time before we see everyone preferring e-readers instead of books. Apart from e-readers, a large number of various smart devices today promise a cleaner environment, but if recycling them is the only way to achieve a true green way, then why cannot we improve the recycling of paper in the first place?

In the article mentioned above, one of the disturbing things was the increase in the energy requirements of data centers in an exponential manner. Again here too, various companies are quick to highlight their green data centers that reduce their energy requirements on non-renewable energy sources. But one wonders if there are these green data centers, then why is the energy requirement of these data centers still increasing.

Hence it is of importance to the media that they portray the right state of so called environment friendly products, and not false claims like a leading telecom provider of India that encourages mobile usage to save trees in its newly launched promotion campaign.

Open-Source Content Management Systems that You can Use to build the website of your dreams

Terms and conditions (unfortunately) apply

Gone are the days when people used to turn towards developers to create content and feature rich websites for them. The developers, in turn, created large groups and used (almost religiously) different programming languages/platforms to build the web application of their choice. But specialized software have made this process largely automated today for general purpose websites.
These are called Content Management Systems (CMS), and are highly customizable web applications. To put in other words, a CMS is a fully built web application that is just waiting for you to customize it.
A CMS features a dynamic website, complete with different modules, types of users, extensibility/add-on options, exporting, tagging, commenting, etc that can be created by a web based GUI. Technically, a CMS website has a two tier architecture involving the website and the database. Generally, there is little or no support for middleware, web services and other subtleties. As most of these are written in PHP with MySql as the database, knowledge in these areas definitively help. However, for purists in other language platforms, there are CMSs written other platforms too.
However, the use of CMS doesn’t mean that there would be end of customized (conventional) websites that are created by programmers today. CMS is largely targeted towards creation of web content for individual use and by small and medium scale organizations. What you need is just a basic set of skills like knowledge of servers, etc to get it up and running. Occasionally, you might run into problems and might search from the web based resources and communities for your problem redressal. This process might also involve some hacking inside the application, but broadly speaking, one person having some, if not all, knowledge in website maintenance can easily cater to a large number of such applications.
Broadly speaking, CMSs can be categorized into the following categories:-

1. Portals or General Purpose
These are the most generic versions of CMSs and can be used by non-technical users to publish their own content. Various community websites (like osum.sun.com), online resumes, etc can be created using these. They support plug-in architecture, which is used to add specific feature into them. The top CMS solutions for these are: - Joomla(http://www.joomla.org) and Drupal(http://www.drupal.org)
2. Blogs
Specialized versions of CMS are there that are aimed towards ease of creation and usage for weblogs or blogs. As millions of people use different kinds of blogs today, there is need for ease of creation of these blogs. Best known CMS in this category that comes into my mind is Wordpress (http://www.wordpress.org)
3. E-Commerce
Even after the dot com burst, there is a steady demand for e-commerce as internet is the way of future. By and large, e-commerce websites provide facilities for product inspection and purchase. This involves both the buyer and seller party in different aspects. So, there exists a well defined category of expectations in this area.Magento(http://www.magentocommerce.com) alongwith many others offer easy e-commerce website creation.
4. Wikis
Given the popularity of Wikipedia (http://www.wikipedia.org) and usage of wikis, both internally and externally. It is not a surprise that wikis are an integral part of Web 2.0 technologies. For ease of creation of wikis, there are a large number of specialized CMSs like MediaWiki(http://www.mediawiki.org) and DokuWiki(http://www.dokuwiki.org) alongwith others.
5. Forums
Searching for problems over internet aren’t limited to googling or yahooing (or whichever mutant you decide upon), but involves a community oriented approach. Most of the websites today offer forums and some are even dedicated towards running of these forums. One of the reason Ubuntu is so compelling to use is that for almost any Google search involving ubuntu problems, there is a link to ubuntu forums. Having said that, I'd like to point towards JForum(http://www.jforum.net) and MyBB(http://www.mybboard.net), whose implementations I use almost every other day.
6. E-Learning
This is also a facet of society that is going to be affected by internet. Usage of this avenue is still in a nascent stage. However, like BPO, this is also expected to pick up and has a large potential, especially from Indian IT Industry point of view. Some of the CMSs that came to my knowledge are Dokeos(http://www.dokeos.com) and Moodle(http://www.moodle.com)
7. Collaboration
Information Systems (IS) begin inside an organization. In order to build a successful intranet, various organizations have gone on that extra mile and created/purchased an in-house solution for themselves. However, open source CMS solutions are also there for the technology and budget constrained crowd. These are also specialized versions of their counterparts and can be used to collaborate between different IS within an organization like MIS and ERP, and between different departments like production, marketing and HR. Alfresco(http://www.alfresco.com) and Nuxeo(http://www.nuxeo.com) are some of the well-known CMSs aimed at enterprise collaborations.

Thus there are a large number of CMS that are waiting to be used (with minimal of programmer intervention) and are available free of cost. These are also open source software, so if you are interested, then you can see how they are actually coded and can tweak to your needs. Being open sourced also has the added benefit of a community driven approach that helps people to learn and help troubleshoot their problems.

After reading this, I am sure that you must be itching to get started. Wishing you the best of Luck, go add some wings (or webs ?) to your dreams.

Importance of a Build Utility-3

Wrapping up my discussion about the build utilities, I’ll be covering Maven (http://maven.apache.org) Build Tool in this blog post.

As already discussed, there is a continuous thirst amongst developers to streamline and automate their projects/applications. Going one step further from the build routine leads to the application creation and maintenance, which is automated via Maven?

Maven is a departure from the existing build technologies, which follow a procedural route, and instead, provides a declarative way, using an xml file, to describe the project.

In large scale projects, there is a need for a large number of libraries. This requires external files in the programming context (read as .jar files in classpath). In Maven, we specify these requirements as dependencies. When the application is executed, these dependencies are downloaded from a central location and kept in a directory at the local computer for usage.

Note that in Maven, we use a lot of the Convention Over Configuration stuff, so if you try to ‘bend’ the defaults on your own, it can cause some headache-inducing  problems (which means that Maven is not for everything and everyone).

Project Types:  Archetype

An Archetype is a template for a project that is created to create a module. This gives us a starting point for our application. We can create such an archetype by :-

mvn archetype:generate

Now we have to answer some values for our project. This is our project type, the group ID, maven ID, Version and the package name of our application.

After the successful execution of this command, the project structure gets created and we have a pom.xml file at the project root. This file is called as POM (Project Object Model) as it contains the information that Maven needs in a declarative and reusable across different projects.

When we build our project, it undergoes a lot of stages or phases (like compiling, unit testing, packaging, deploying, etc) in an ordered manner.

A Small Example

First we will generate our project skeleton using the archetype:generate command

Now, we will get this :

Here, we would set up the project type (in this case, I am setting up 18, for a blank web application).

Then, we will specify the GAV(Group, Artifact and Version) values as well as the default package. After confirmation, our project structure would be created.

Now we can start developing our applications. As soon as we are finished, we can package our application as mvn package command.

Note that we did not created any build scripts ourselves; Maven only asked us about the type of project that we need. So our productivity increases as well as we can adhere to unified build standards.

If you look at the /target folder, then there would be a simple-webapp.war file, which can be deployed in any web server. To run this on tomcat server, for instance, simply issue a mvn tomcat:run

Apart from the build lifecycle discussed here, there are other lifecycles such as cleaning and site generation.  It is worth mentioning that, we can make the project an Eclipse project by mvn eclipse:eclipse and so on for other tools.

Now, mainly, we have to take care of the pom.xml file that contains the dependencies, which may arise as and when we expand our application. Rest everything is left to the build utility.

Conclusion

Although it is early for me to comment upon the future of this or any other build tools, but we can expect more automation in future.

Cloud based application servers can provide for automatic classpath management (like IDEs) and maven would not only take on ant as the de-facto tool in java, but also result in numerous spoof offs for other technologies.