Author Archives: Cecil Williams

Agile Manifesto – Responding to Change Over Following a Plan

Is it really possible that intense planning and the ability to respond to change can co-exist within the same development process? If you are wondering this, then you are not alone. Clients regularly ask us if Agile software development teams follow any sort of plan or are they just feel good, free for alls? In this article we explain the types of processes that can be adopted to allow your teams to plan while still responding to change.
Cecil Williams
Cecil Williams

Latest posts by Cecil Williams (see all)

Traditional Software Development
Traditionally, software development teams viewed the cost to change something as increasing over time.  To save money these teams required customers to define everything they wanted before they ever started building the system.  While this sounds reasonable, we all know that something will always be missed.  These missing requirements will creep into the project little-by-little.
Many organizations try to prevent changes by making it very difficult, if not impossible, to inject changes after the initial planning phase.  This resistance drives many teams to add everything, including the proverbial kitchen sink, to their initial requirements to avoid the pain of adding changes later.
While this seemed like a good idea at the time, our industry has learned that allowing change is imperative for companies that must compete in a fast paced, cut throat, rapidly changing marketplace.
The last decade has seen several software development processes become popular that allow for planning and change to happen at the same time.
Agile Software Development
Agile software development processes accomplish this through different levels of frequent planning and re-evaluation. The first and highest level of planning is release planning.  Within release planning, teams agree on the features to include in a release.  At this level of planning, features remain very large.  The purpose of this planning session is to paint a large picture of the project with very large paint strokes.  Once these large strokes are grouped into meaningful releases, we proceed to prioritize each release and then break them down into smaller time periods known as iterations, based on priority order.  Each iteration is typically limited to two week periods.
At the beginning of each iteration we agree on which features the team thinks they can complete.  These features are broken down into stories, which are kept in a prioritized feature list.  By working in iterations, the team has the ability to adjust what they are working on every two weeks.  Thus, if a new requirement is discovered, the team is able to incorporate it without difficulty in the next iteration.
This approach intensifies the investment of planning as the team gets closer to a given iteration. Focusing on a few features intensely empowers us to lock in a limited number of decisions that often uncover information that effects later decisions.  While the old style of up-front planning attempts to uncover these pieces of information early, a significant amount of this information cannot be fully understood until we start to develop and use a working system.  No amount of thinking can replace hands-on experience with the real system.
As the team works in an iteration, the stories are pushed from one stage to the next. The stages vary from company to company, but typically include development, testing, and deployment.
Once an iteration is completed we take time to reflect on what we learned.  This review meeting is called a retrospective.  In this meeting the team discusses what went well, what did not go well, and what changes we want to make.  This meeting helps us learn from our mistakes and make a commitment to improve.
Lean Software Development
Taking the Agile software development process a step further, the lean software development approach focuses on limiting the work in progress based on the constraints of the team. The team cannot push work to the next step.  Instead, the downstream team members pull work into their stage when they are ready to work.
This is done to prevent any one stage in the process from completing more work than the other stages can process. If one stage finishes work and the next stage cannot work on it, then this is considered wasted inventory. Lean software development borrows the theory of constraints from lean manufacturing, in that it limits the work in progress to the slowest stage in the process.
By limiting the work in progress, teams are able to identify bottlenecks in their process.  These bottlenecks may be due to resources, bureaucracy, time, distance, or any number of reasons.  Lean software development teams focus on eliminating their bottlenecks so that they can function at their optimum.
Lean software development processes do not use fixed time periods like iterations.  Instead, a lean process will continue to pull work at the rate that it is capable of producing features.  And rather than having a scheduled release, the team will simply release features whenever the team determines is appropriate.
Lean Startup
Teams are starting to go even further than the lean process, by combining the lean process with ideas from startup companies.  These teams are focusing on a single feature and all the variations that a user might do with that feature.  The lean startup process uses value stream mapping to determine what are the most important parts of a feature to the users.  Then they build those parts of the feature and deliver it to the users.  This allows them to get even quicker feedback and validate whether they are building a desirable product.
Final Thoughts
The last decade has seen several software development processes emerge for responding to change over following a plan without creating destructive chaos.  Following an intensely focused plan is far superior to creating a bloated, expensive, “perfect” plan up-front that cannot be changed without adding significant cost.  Responding to change is not only more effective, it is imperative for companies that must compete in a fast paced, cut throat, rapidly changing marketplace.

By David Kessler and Cecil Williams

Is it really possible that intense planning and the ability to respond to change can co-exist within the same development process? If you are wondering this, then you are not alone. Clients regularly ask us if Agile software development teams follow any sort of plan or are they just feel good, free for alls? In this article we explain the types of processes that can be adopted to allow your teams to plan while still responding to change.

Continue reading

My Top 4 Takeaways from NFJS 2013

**Android Development**
Google is working on Android Studio, which is built on the community edition of Intellij IDEA.  You can learn more and download the early access preview at http://android-developers.blogspot.com/2013/05/android-studio-ide-built-for-android.html.
A great book for Android development is “The Busy Coders Guide to Android Development” by Mark Murphy.  He uses an annual subscription model for the book and updates it regularly. He adds new material each month.  This way your book is never out of date. You can learn more at http://commonsware.com/Android/
It is possible to seed up the Android emulator!  Intel has developed the Hardware Accelerated Execution Manager (HAXM).  Selecting this as the emulator will drastically reduce the amount of time it takes to start the emulator.  You can learn more and download the HAXM at http://software.intel.com/en-us/articles/intel-hardware-accelerated-execution-manager.
Would you like to view your physical Android device on your computer?  Well now you can using a program called Droid@Screen by Jens Riboe.  You can learn more at http://droid-at-screen.ribomation.com/.
**HTML5 Offline Applications**
The HTML5 specification supports client side storage so that applications can work in an offline mode.  All of the latest desktop and mobile browsers support HTML5 client side storage. To tell the browser that you application supports client side storage you have to add the “manifest” attribute to the html tag at the top of the document.  You can learn more at http://www.ibm.com/developerworks/library/wa-offlinehtml/.
**CoffeeScript**
After seeing CoffeeScript, I don’t think I will ever write JavaScript again.  CoffeeScript is to JavaScript what Groovy is to Java.  It provides a much simpler syntax than JavaScript by incorporating language features from Ruby and Python.  CoffeeScript compiles into pure JavaScript and is compatible with all JavaScript engines.  You can learn more at http://coffeescript.org/.
**Server Side JavaScript**
There is a JavaScript runtime engine called Node.js.  The authors designed it for building fast, scalable network applications.  Node.js allows you to try JavaScript without needing a browser, by running the Read-Evaluate-Print-Loop (REPL).
Node.js has a large ecosystem.  For example, there is NodeUnit and Buster.js for testing, Jade for tempting, Express for web applications, and Connect for middleware.  Even CoffeeScript will run inside Node.js.  This ecosystem is managed using the Node Packaged Modules (NPM) registry.
NodeUnit and Buster.js provide new ways to test JavaScript, either within a browser or Node.js.  This is important since jsUnit is not longer actively maintained.

One of the best software development conferences you can attend is the No Fluff Just Stuff (NFJS) conference. The conference  is small and the speakers are mostly consultants working in the field.  I attended my 9th NFJS conference this year, and as always, came away with some great information that I can use right away.  So here are my top 4 takeaways from NFJS 2013:

Continue reading

Acceptance Testing presentation at Iowa Code Camp

I had the opportunity to present at the eleventh Iowa Code Camp on June 8, 2013.  The title of my presentation was “Easy Acceptance Testing.” The purpose of the presentation was to discuss an acceptance testing framework that Source Allies, Inc. developed for a client while working on a large scale web application.
I started the presentation with a discussion on the various types of software testing. Then I focused the discussion on acceptance testing.  I discussed some of the disadvantages and advantages of acceptance testing that I have observed.  I discussed some of the various tools available for acceptance testing like Cucumber, Fitnesse, and Selenium.  Finally, I demonstrated a generic version of the acceptance testing framework we developed for our client.  The demonstration was executed against a randomly selected website to show how easy it is to create acceptance tests for a web application using this framework.
The framework is written in Groovy and uses Selenium.  It takes advantage of some of the language features of Groovy such as Closures and Delegates to simplify the formation of test cases.  The test cases are defined in an XML format so that they can be easily changed.  The framework also supports nesting test cases inside other test cases.
The presentation slides and generic framework code is available for download on GitHub at http://github.com/cecilgwilliams/

I had the opportunity to present at the eleventh Iowa Code Camp on June 8, 2013.  The title of my presentation was “Easy Acceptance Testing.” The purpose of the presentation was to discuss an acceptance testing framework that Source Allies, Inc. developed for a client while working on a large scale web application.
Continue reading

Agile Manifesto – Customer Collaboration Over Contract Negotiation

By: Cecil Williams & David Kessler

Do you ever wish that companies would trust their employees and business partners instead of insulating themselves with contracts and policies?  For many companies, each discipline operates out of its own department requiring other areas to document exactly what they want and what they are going to do.  This provides a means to assign blame when projects fail.  In stark contrast, Agile suggests that we should favor shared collaborative efforts over ridged, locked-in, contractual obligations.

ThoughtWorks releases ebook on Agile Project Estimation

ThoughWorks Studios has released an ebook titled “How do you estimate on an Agile project?” where they explore common approaches and their adaptions from real-world projects.  The book is comprised of several authors, most notably Martin Fowler. In this ebook they discuss why teams estimate, different methods that teams use to estimate, and provide a couple of case studies.
Continue reading

Agile Manifesto – Working Software Over Comprehensive Documentation

Do you sometimes feel like your team spends more time documenting your system than building it?  One of the biggest hindrances to progress in a software project is documentation.  The Agile Manifesto prescribes that teams should value working software over comprehensive documentation.  It doesn’t mean that you should not create documentation; it means you should create documentation that provides value and at the same time does not hinder the team’s progress.

Continue reading

Using Git with Subversion

If you haven’t heard of Git or don’t understand why you should use it, checkout the talk given by the author to Google (Torvalds, 2007).  Git is an excellent version control tool for agile software development.  But many of us may not have the luxury of using Git because our company has deemed that we shall use Subversion.  Now Subversion is not a bad tool and has added some nice features in version 1.7.  But my preference is to use Git. Continue reading

Agile Manifesto – Value individuals and interactions over processes and tools

David Morgan and Cecil Williams, March 25, 2013

One of the biggest hindrances to progress in software projects is bureaucracy.  Rigorous processes that must be followed unswervingly, deliverables changing hands between independent groups and required approvals – hand-offs, sign-offs, and stand-offs – all get in the way of software projects making valuable progress.  So how would you change that? Continue reading

Java method breakpoints are evil

I want to share an experience that my colleague, Travis Klotz, and I ran into recently.

I was trying to manually test a Java web application running in debug mode.  It was running really slow, taking several minutes to launch after the compile was finished.  And when it did eventually start, using the application was very slow.  Pages would take almost a minute to render.  So Travis and I started trying to determine the cause. Continue reading