GenX SDLC mindmap

I have tried to capture all essential things that different stakeholders in a software development project need to keep-in-mind for successful execution. If one does a careful study, s/he can find that there is nothing new mentioned here except for few best practices followed in agile style of software development. Its just a easier way to capture, convey and enforce. If we follow these few and simple things, most of our development projects can be saved.

If the image is not clear, please try to access the image URL directly.

JAX India 2007 – Bangalore day 3

Below is the coverage of todays sessions and my takeaways. The slides for all presentations are available here.

JSF and AJAX : Best of Friends (by Craig McClanahan, SUN Microsystems)

• The motive was to convey various means of achieving AJAX while using JSF. Though all means are workarounds in my opinion. JSF specification should have built-in support for AJAX. It lost out in this front because of the delay in finalizing the specification and AJAX peaking up during the same time.
• The means are : (a) DIY (Do It Yourself) (b) Use JSF components with native AJAX (c) Wrap client side JS libraries (d) Make non-JSF calls to the web server.
• DIY – Most JSF components have JS event methods. Leverage that along with own JS methods and XMLHttpRequest or other client side JS toolkit like Dojo, Prototype or Scriptaculus. Involves lot of work. Implementing page refresh might be tricky.
• JSF with native AJAX – Components take care of making async calls and updating DOM. Simpler to use. Loads of OSS and commercial ajaxified JSF components available. e.g ADFFaces, MyFaces, etc
• Wrap JS libs – Strongly suggested Jmaki which wraps different client side AJAX libraries like dojo, prototype etc.
• Make non-JSF calls – You can choose to use any of the AJAX libraries and make them talk to a servlet directly instead of going thru the JSF life cycle. Handling the component tree update will be tricky.
• choose any of the above options based on whether you need to keep the component tree in sync with the DOM updates.

Should you adopt/migrate to Struts 2.0? (by Harshad Oak, Rightrix Solutions)

• Provides an overview of new features of Struts in 2.0 release. Its basically like Struts 1 + WebWork = Struts 2.
• Features include annotation support, interceptors through servlet filters, convention over configuration, derive method name from URL, concept of value stack, new tag libraries, a Guice based minimal DI container to integration with Spring, no form beans etc
• Integration points for Spring, AJAX frameworks like dojo, GWT etc.
• Package names now contain com.opensymphony.*.
• Migration from Struts 1 to Struts 2 is difficult because of such drastic changes but migration from Webwork is lot easier.

My opinion – its a mess now, it is dieing. The code code sample he shown looked lot messier, a result of merging two frameworks. The author himself seemed directionless like the framework and mostly tried to highlight that the framework supports all the buzz words in web framework market these days. Guess Webwork is banking on Strut’s image now to sell itself. Pity for both of them. Good for us (developers) since we have two frameworks less to worry about now.

Can tools improve even a power geeks productivity? (by Craig McClanahan, SUN Microsystems)

• Brings out the point that geeks who like playing with their good old editors using the combination of hot keys and the keyboard, can be more productive if the IDE has appropriate features.
• Few features that makes a java IDE good are – documentation lookup, refactoring, real time debugging, unit testing support, version control support, database administration, deployment, generate boiler plate and plumbing code, allow maven / ant structuring, integrate runtime dependencies, heterogeneous programming language support, generate skeleton OR mapping and support for popular frameworks etc.
• Demonstrated Netbeans IDE supporting these features, though he named Eclipse in the context. So i would not say that we was solely pushing the SUN product by throwing a catchy session title.

You can’t just buy an Open Source community (by Neelan Choksi, COO Interface21)

• This talk was to highlight that all the commercial vendors taking the open source route to stay in business will not succeed. They can not buy the community by open sourcing their products e.g OpenJDK, OpenJPA, JBuilder etc etc.
• The only sensible thing he talked about – Community is the most important factor in success of open source projects. You need to build community and their are few approaches to do that.

Otherwise the talk was complete waste of time. More focused on picking up failures from rivals and quoting Interface21 as the rightest thing to ever happen. The less you write about his presentation skills, on stage persona and language command the better it is for Interface21. An instance of catchy title but patchy content.

Why is everyone so excited about Ruby-on-Rails (by Neal Ford, Thoughtworks)

• Title says it all – marketing of RoR. However i still wanted to attend to see whats inside RoR. And to be honest, i was taken aback, throughly surprised with zillions of questions shooting here n there in my mind.
• Few features – RAD development (they mean it, needs to be seen if it works in enterprise apps), agility, instant feedback, OR mapping via ActiveRecord, no compile/deploy etc, scaffolding, testing generation, web 2.o support etc.
• Follows standard folder structure which helps in getting rid of configuration files, making safe assumptions. Generates method code at runtime based on need.
• Recommends Streamlines, a 3rd party scaffolding library.
• Admits it slowness now but expects drastic improvements in next release.

my thoughts – this is a completely different way of developing web apps. Given the productivity features and all the buzz around it, i feel the time has come for a try on it for an agile development project.

SOA: The future of distributed computing? (by Neal Ford, Thoughtworks)

• I am not a SOA fanboy but attended it since none other parallel session were any better. Not sure if i followed him properly but i guess he started with bashing SOA and ended with the note that it has the best chance to work this time for distributed computing.
• One should download the slides from his website and go thru it. Its pretty humorous and informative at the same time.

Overall, one key point to note is that the audience is much more patient and lenient while listening to the established speakers as against the local ones. I had expected more skilled and professional audience since most of them are at architect or designer level. But few basic ethics like allowing the speaker to cover the topic before asking ahead or out of context questions, things like limiting conversations to certain iterations etc were clearly missing and thus few of the sessions were reduced to mere show-off events than for knowledge exchange.

An innovative approach to training in IT industry

Training is an important part of success of IT company; it does play a similar role in a successful career of an IT professional. The graduates who join IT companies’ fresh from their college campus mostly come with theoretical knowledge on various subjects spanning programming languages, data structures, operating systems, databases etc. Some don’t even know anything other than just one language (say Java) because their graduation discipline doesn’t include them. They just learn a language themselves to increase their prospects of an IT job. The point is, every company gets a mix of graduates as their freshers batch. So the onus is on the company to prepare them to be useful and productive. To achieve this many companies have extensive training programs, some of them spanning to six months.

However, even after these months of training, of late we have seen that the graduates have not added much to their technical skills after the program completion. Obviously there is some problem somewhere. I have tried to find out the flaws and am proposing an alternative approach to training fresher’s in todays IT companies.

Flaws I could see in the current system of training adopted by most IT firms:

• No job rotation for trainers.
• Lack of seriousness from either party on the training.
• Mode of presentations and the quality of trainers used for training.
• Multiple Choice Questions (MCQ) used for testing the candidates.
• Improper evaluation of case studies or projects.
• Lack of discipline.
• Question papers used just for conducting tests, nothing beyond it.
• No efforts towards improving on the attitude and acclimatize to corporate lifestyle.

Below is an innovative approach where I tried to solve the above problems in a different manner while retaining the current best practices,

• Improve the attitude of the trainers. Consider the training department as an institution by itself and the mandate of the staff being to impart focused technical education with sincerity and right attitude.
• Think of the freshers as babies in the world of IT. So what they learn depends on what you teach and the kind of environment you provide. Effort should be spent in making the environment education friendly and imbibing the right attitude in them towards technical learning.
• The trainers should be experts in the subject in hand. They should have hands-on experience on the subject and enough work experience to pick up different real-life scenarios and examples on the subject for discussion.
• The trainers should be rotated among projects and training. No amount of theoretical knowledge can ever replace practical experience. So it’s a must for the trainer to work on projects and pick up knowledge.
• Do not read thru a presentation. They are almost always concise and not enough to cover the subject in full especially in the context of technical teachings.
• Instead, provide the students enough material and time to read by themselves. They can be in form of URLs, soft copies or hard copies. They must have access to machines with proper configurations to do their practicals.
• Hold Q&A sessions everyday to clarify any doubts they may have on the subject.
• If you see a topic little complicated for the freshers to comprehend, do take a lecture and explain the topic in depth.
• Each subject should conclude with a test. The test must contain subjective type questions targeted at concepts and fundamentals of the subject. A person who is able to answer the subjective type questions correctly can be safely considered to have learnt the subject.
• After the test, do ensure to discuss the question paper in depth. This helps them to identify and rectify their mistakes.
• You should also consider an overall test after completing all the subjects of training.
• Each one of them should do a complete project involving all the subjects covered during training. And each project should be evaluated properly and the candidate should be given proper feedback.
• Apart from above there should be regular efforts towards encouragement and discipline. Different people have different ways to achieve that.

The above approach to training needs a genuine & full time involvement from the trainer. The focus should be more on those topics which are frequently used in daily project lifecycles instead of trying to cover the complete subject. Because of the need for higher involvement, highly qualified trainer and nature of the approach, it is not very scalable. If you are a company which needs the training department to be a factory to churn out thousands of people on monthly basis then I am afraid this approach will not work unless your training department is staffed adequately and has enough resources.

Issue/Defect management in Onsite-Offshore delivery model

An SDLC project when executed with distributed teams needs attention in many areas involving processes in addition to technologies. The maturity of the processes and the sincerity of the team following them, goes a long way in deciding the fate of the project. One such area of concern for almost all projects is the management of Issues (till testing phase) and defects (there after).

Issues can be of any type, ie it may be requests for clarifications of any requirements, setting up of customer specified environments or any other thing that needs a clarification from a geographically distributed team. As the number of issues grow, it necessitates a consolidation, tracking mechanism and process for followup & closure. Traditionally people resort to xls sheets. They create an xls sheet (mostly issue-log.xls ) with numbers of columns varying according to the experience of the person creating the sheet, consolidate the issues in it and put a process in place for shuttling the xls sheet between onsite and offshore in a specified frequency with updates happenning on either side.

There are a lot of problems with this approach. Namely,

>1> It needs single point of contact on either side. It creates a dependency on those persons. God forbid, if any one of them falls sick, your project falls sick.

2> More often than not the team runs into version issues of the sheet, ie different teams working with different versions of the sheet. Some people go to the extent of attaching version numbers with each xls, only making matters worse.

>3> Managing the file becomes difficult once the number of issues grow beyond 100s.

>4> A lot of issues need discussions. It can happen over phone or in a mail chain. In either case the information related to the issue gets scattered into various media. So the xls sheet alone doesn’t provide complete picture on the issue at any time.

>5> At least one resource each side is wasted for handling the file. If you don’t dedicate a person to handle the issue log on each side then you are bound to get into a version issue, loss of issues or orphan issues.

>6> Situation is much more complicated if you have to manage defects. Because defects usually have a work-flow and need to exchange multiple hands during its lifecycle. Using xls sheet to manage the life cycle is hell of a task.

If your issue/defect management is not correct, you are bound to fail to close many issues which only gets highlighted during UAT phase of the project and becomes a reason for spoiled relationship between you and your customer.

My experience says, these tasks should be automated through introduction of appropriate tools. There are quite a lot of commercial as well as open source tools in market today that help in issue and defect management. Commercial tools tend to become complicated in their effort to provide maximum features, thus increasing the learning curve and reducing the ease of use. We have used open source tools effectively for this purpose and they provide the bare minimum features required to do the task in hand effectively.

Few tools one can try to use are, JTrac, BugZilla etc.

Managing concurrent change with Eclipse and CVS

Many of the software projects developed today use distributed and collaborative development environments. Using geographically distributed team vendors are able to achieve ‘24/7 active’ development of their software. It has its own list of challenges and there are tools aplenty to address those challenges in both OSS and commercial category. Here we discuss one of such peculiar problem (i.e, managing concurrent changes to code base) and explain how Eclipse + CVS combination addresses it effectively.

Due to concurrent changes to the code and improper version control process (or lack of sincerity from developers) we almost always land up in ‘conflict’ situations and spend extra effort in resolving them. Below I discuss a process that helped me in a large development project while allowing me to just work with my development IDE. No extra tools required.

1. CVS Features for managing concurrent change:

CVS provides various sets of features to help the users manage concurrent change effectively. These features work hand-in-hand to help the team. Some of these features are:

• The “watch” feature: To utilize this feature the user explicitly expresses interest in change (edit/un-edit/commit) in a particular resource. CVS takes care of notifying the user whenever any user executes an operation of his interest on the resource viz. edit/un-edit (as explained below) and commit. This feature is not supported by the Eclipse’s VCM (Versioning and Configuration Management) modules’ CVS implementation as in Eclipse 2.1.

• The “edit” feature: Typically any resource that needs change can follow any of the following paths under CVS:

The straight path (I) from an unchanged resource to the new committed resource is a common way of using CVS.

The alternate paths (IIa and IIb) are also supported by CVS and provide another mechanism to manage concurrent change.

If every user religiously follows path II to issue a “cvs edit” before (s)he starts work on a resource and then issues a “cvs commit” or a “cvs unedit” when work is respectively finished or needs to be rolled back, then CVS can keep track of all current “editor(s)” of a resource.

This conversely gives any other user who wants to work on the same resource an opportunity to check with CVS as to the current “editor(s)” of the resource and take appropriate steps. So the modified path II now becomes,

2. The Eclipse Value-Add:

Eclipse goes a step further to help you achieve this. Under Eclipse, a project can be set to send automatic “cvs edit” commands to the CVS repository whenever a resource is changed / “edit”-ed by a user. All resources for such a project get checked-out as “read-only”. When an actual change is made to the file from within Eclipse, Eclipse switches off the read-only flag and send the “cvs edit” command to the repository.

The story doesn’t end there! Eclipse goes even further. If it so happens that the file being “edit”-ed already has registered editors, Eclipse gives you a “warning” stating who is currently changing the file!!

As such both the manual steps of Path II viz. checking the “editors” of the resource and issuing the “edit” command are automatically taken care-of by Eclipse. All you need to ensure is that you work under Eclipse and respect the warnings – that’s all!!

3. What You Need to Do

• Ensure that eclipse is setup to use edit and watch features.

• Make sure that all files are edited under Eclipse

• IFF (and that should not usually be necessary since Eclipse has editors for almost everything!) you do change anything outside Eclipse, make sure to send an explicit “cvs edit” command from Unix / WinCVS / Eclipse itself!

• When Eclipse warns, don’t ignore. Consult with the existing “editor”.

PS: Special thanks to Sumit Sachdev for his contributions to this article.