I am delighted to announce that today I am launching a series of screencasts that attempt to get across a working method for software development teams that puts the odds of success in their favour.  The series is called Software Success Disciplines, and will also come in classroom form in the near future.

The practises are nothing new.  And yet they are not put in place in most software projects, as far as I can tell.  The screencasts will roll out over the following months, using the following as a kind of guide as to what will be covered:

* empty directory structure
* discuss directory layout and project naming
* put directory layout in place
* begin hello world test case
* discuss unit testing
* discuss frameworks (junit, testng)
* download and install junit
* Write test case
* Explain TDD
* Explain Red/green/refactor
* we need to run the test
* discuss build systems
* discuss options (ant/maven)
* download and install ant
* work through the ant file to compile and test
* compile and test
* turn into web application
* extend ant file to build WAR
* demo the WAR working
* clean up the ant file
* introduce the concept of source code control
* discuss options
* import project into subversion
* introduce the concept of continuous integration
* discuss options
* setup hudson and integrate our project
* begin a more complex project task – a stock quoting system backed
by yahoo.
* introduce mocking/stubbing
* write yahoo stock quoting stub by hand
* TDD the quoting service
* write a simple jsp to take the stock symbol and display the price.
* deploy and check
* introduce the concept of releasing, expecially releasing early and
often, and in an automated way
* introduce branching and tagging
* extend the ant script to enable release creation
* release
* introduce mocking frameworks and discuss options.
* download and install mockito
* rework previous test to use mockito stub instead of hand written
one.
* introduce acceptance testing
* discuss options
* choose concordion
* write acceptance test for previous work
* explain that this should be done first
* extend ant script
* demo the acceptance test failing
* make it green
* extend the project to include the idea of a User and a Portfolio
* Introduce the concept of schema evolution and discuss the options
* choose one (I am not sure which one to choose yet)
* evolve the schema to include user and portfolio tables.
* write the associated java objects
* write the associated data access objects using JDBC
* introduce concept of integration test
* write integration tests for the DAO objects
* rework the jsps to include login, add to portfolio, display
portfolio
* all done with acceptance tests up front (this will involve
evolving an acceptance test instrumentation language that is very very
cool 🙂 )
* Deploy and demonstrate
* release
* discuss persistence frameworks.  discuss options and benefits.
mention caching.
* install hibernate
* rework to use hibernate instead of jdbc
* Discuss web frameworks and options (I am not sure if its too early
to have this discussion yet, maybe after next ‘iteration’).
* install GWT
* Rework to use GWT and discuss
* release
* extend example to allow alerts on price movements
* Rework the UI (might be better to show that straight JSP starts to
fall down at this point and then move to GWT)
* Produce an email server
* Integrate email server using JMS
* All acceptance tested and TDD’ed.
* Deploy, demonstrate and release.
* Introduce IOC containers and discuss options.
* Install spring
* Rework to use spring.
* Release.
* More steps to be added depending on what might need to be covered
for particular students.

Following that, I hope to get around to producing a follow-on series that discuss the working environment, and the way a successful team interacts in the office.  These videos will be more traditional videos, instead of screencasts.

I hope you enjoy the content, and I hope I can keep cranking it out 🙂

Keep well,

Mike