October 26, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

Five To-Dos for a Fledgling Java Team Leader

  • March 28, 2003
  • By Roman Rytov
  • Send Email »
  • More Articles »

4. Define Project Rules

This rule is about defining definitions (sorry for the tautology). As the leader of your team, you are responsible for the code from any point of view. It starts from a code style your team has agreed upon to follow and ends up with the names of features, nodes, and technical terms your command members use when communicating with each other. I'm familiar with stories where a manager describing his point doesn't know for sure how the matter he's talking about is named. Insist on strong and even documented definitions of common project terms as the official internal language in the team (I got this practice from Yair Altman and found it extremely useful).

Sometimes, misunderstanding leads to very disappointing results (as when two different things are called by the same name or even not called by a certain name at all and a developer implements a feature for an unexpected node). Regarding a code style, the point is standardizing. Define a single accepted standard that all of your developers will be obliged to follow. If your VCS system allows you add a preprocessing script on the server, write one that not only reformats the code according to the style but also makes additional checks (for example, checking the appearance of System.out in the code). Another idea is to define a header of any text file in the project; it should report the author of the file, creation date, modification date, and a revision number. It gives you a possibility to analyze the origin of the code on the production site (in case of a problem investigation).

5. Put Bugs into Irons

Create a system of unit and functional tests. For every public method, except for very trivial ones, create a unit test-set of checking calls for the function with regular and sabotage parameters. Check that test results for both cases are correct or processed expectedly. When a feature or certain functionality is finished, write a functional test that checks not only the function as a unit test does but all the way from the front-end to the end and back. Run the test several times with valid and wrong parameters and check that the system manages calls properly. When a bug is found, first add a test that crashes on the bug and only then fix it. When the project grows, the unit and functional test will grow also; every new bug will get its own "chain," preventing it from appearing in the future. Run all the tests as part of the nightly builds, thus making outgoing versions more reliable and more tested.

The idea of testing your code usually meets opponents among people never tried it in practice. They claim test writing is just a waste of time, but if you analyze how much time is spent re-fixing bugs or re-coordinating correlations between different developers (or even teams), you'll see that you gain much more than just profit in time; the amount of grind, unskilled labor, and definitely double work, will lessen significantly. Some go farther and plan all their design process based on test writing preceding code writing. They create the casing for future functionality that insures against unexpected changes in it (see TDD in the Resources section).

Summary

The advice I listed above is not inventions and for some it may look like there's nothing that has added value, but I saw a few teams and projects suffering from the lack of any replacement of such rules and in my own experience I found them very effective. I hope they'll help others as well.

Resources

  1. The old good Bugzilla—http://bugzilla.mozilla.org,
    and Scarab—http://scarab.tigris.org.
    List of such systems with reviews: http://www.stickyminds.com/tools.asp

  2. The biggest portal: Sourceforge (http://www.sourceforge.net),
    Java OSPs: Apache Jakarta (http://jakarta.apache.org)

  3. The famous VCS—CVS (http://www.cvshome.org);
    a CVS competitor: (http://subversion.tigris.org).
    General Software Configuration Management patterns: (http://www.cmcrossroads.com/bradapp/acme)

  4. Java code style. Java code style formatter Jalopy (http://jalopy.sourceforge.net) has lots of useful links on the realm

  5. Testing: JUnit framework (http://www.junit.org)
    JMeter—Java load-test framework (http://jakarta.apache.org/jmeter)

About the Author

Roman Rytov has over 7 years of programming, design, and leadership experience. He holds a server team leader position at Entopia Inc (www.entopia.com). Roman and his wife Lia have three children (Valeria, Victoria and Gabriel) and live in Israel. You may contact Roman at roman@rytov.com.



Page 2 of 2



Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel