• 31May

    “The Economics of Iterative Software Development” gave me some excitement, thinking there was finally a concise reference from experts giving examples of projects they participated on, why they failed (with a breakdown of specific areas) and how the different aspects of developing iteratively resolved these issues in future projects - Unfortunately I was slightly disappointed.

    The first chapter is interesting and uses statistics from reputable sources such as the Standish Report. However, the remainder of the book is more of a Project Management guide for both experienced and junior project managers (and project owners) to determine why Iterative Development works in the software industry.

    The authors clearly have experience and this shows. The appendix ‘Getting Started With Iterative Project Management’ is good and steps through the requirements of setting this process up. I especially like how the authors advise on communicating business reasons to the team, something that is largely obfuscated in organizations.

    However, some chapters are just too short! Four pages on automation! This is one of the largest economic gains in the development lifecycle. I would have liked to have seen concrete examples of which parts of the development lifecycle they autmated and how much time or money was saved.

    There are some points in this book I would question, mainly:

    • “Test coverage should be 100% of all scenarios.” If  this refers to all testing, then it is actually uneconomic to have all Unit Testing at 100%.
    •  Most of the cost of software is in post-release maintenance, yet nothing is discussed about this. The Authors state “Achieving results is more important than performing activities as part of a process.” - I’m sure this has always been the case but it is WHAT processes we need to concentrate on that is important. For example, if I create a deliverable on time but it is not maintainable, is this acceptable?
    • One huge economic drain is the YAGNI (You Ain’t Gonna Need It) principle. I have seen reports of up to 50% of features in software never used and most of these never asked for. Yet again the economics of this area is omitted from the book.

    Finally, the authors praise modern software engineering. Any reader of Brooks’ ‘Mythical Man Month’ (an excellent book and one they recommend) will know that issues that plagued the software industry fifty years ago are still largely apparent.

    Iterative development is not a modern way of thinking as projects have used it over the last 30 years. However, the techniques used in implementing this strategy have been lacking. The techniques outlined in this book are largely recognized as being somewhat successful. But in my opinion we have a very long way to go.

    To summerize, Iwould say, a good book for Project Management teams using Iterative Development techniques but sadly lacking on the Economics of the subject.

    Tags: , , ,

  • 03Apr

    Unofficially there are no such things as fixed priced projects in the software industry.

    Of course, officially this term is still used, but lets face it these are no good to the customer or vendor. Why? Because if the project is completed early then the vendor may just work slower to ensure the completion is as close to the deadline as possible (so their next quote for a similar project can be justified) or, more likely, unexpected issues will occur causing the project to overrun in time or money or even be scrapped completely. 

    So what happens when the PMO declares that the project cannot be approved financially with an analysis of all the requirements and costing performed up front (i.e. a fixed price contact)?

    I attended the first Phoenix Scrum User Group last night, where Ken Schwaber was presenting remotely and was given this very scenario. He gave some interesting facts that I believe should be used to educate the financial folks to understand that this is the wrong way to look at project costing. Here are some numbers:

    35% of requirements change on a project (on average)

    50% of features initially scoped are never or rarely used.

    82% of projects fail (this is from the 2002 NIST report where failure is deemed as late, scrapped or not all features implemented that were originally scoped). 

    Using an Agile framework such as Scrum, the customer can see that that backlog is broken down into many tasks which are planned in more detail the closer they are to be implemented. I.e. For the next month here are the details of what we are going to do, how we are going to achieve it and with priorities.

    For the work we are going to do in future months, here is a general overview which will become more detailed as we start the iteration of work for that particular set of requirements in the backlog.

    Apart from a significant increase in risk management (on both sides), this gives the customer multiple chances to change any future requirements (as we know will happen). However, they are NOT allowed to change anything on the current iteration.

    If some work in the current iteration needs to be changed later, we can add this to the backlog.

    If work performed in the current iteration, for some extraordinary reason must be changed completely, then the most we have lost is up to one-months work.

    Compare this to a project where all the requirement are set up front and six months later the customer receives a deliverable way off the current needs, are they going to be happy?

    If the customer still insists that all requirements are expected up front and priced then insist on a contract where no requirements will change. This is far from ideal and a review the customer may come around to a more appropriate way of thinking. If they still persist and are not willing to sign this type of a contract, you are probably best to walk away. Look at the stats!

    Tags: , , ,

  • 27Jan

    No! This isn’t a blog about Code Reviews. It’s actually a book review of Bob Martin’s ‘Clean Code’. However the amount of code to read in the book may seem like a series of code reviews (more on that in a bit).

    Each chapter contains a different subject to enhance code quality.
    From the simple practices that are often overlooked, for example; naming conventions and formatting styles, through the classic tried and tested; Kent Beck’s 4 Simple Rules of Design (Run all tests, contain no duplication, code to express intent and minimize the number of classes and methods); to some gems that can take years to uncover; such as bad practices for returning null (with the correct idiom) and good practices for testing threaded code.
    This reviewer certainly chuckled guiltily when reading some of the examples of code that could be written better (”Oh yeah, I remember doing that once!!”).

    I was surprised to see a few reviews on other blog sites and amazon about the fact this was not written solely by Bob but by different authors at Object Mentor. I actually thought this was a good thing as each chapter is a separate concern and the writing styles differ so the reader can be engaged differently from one chapter to the next. Plus, there is a lot of Java and the change in temperament clears ones head after reading all that code.
    This book does not follow a specific ‘project’ throughout, like many other books today, but concentrates on real world examples to illustrate the points made. This is not a book one can read quickly if the reader wants to real get involved and practice what this book teaches.

    One may presume that my opening paragraph was negative on the amount of code in this book. On the contrary, I found this to be an excellent model to get, mainly inexperienced [Java], programmers to look at more code written by experienced experts and take a look at the internals of classes in popular frameworks such as JUnit and JCommon.

    Chapter 17 is a concise description of each of the smells and heuristics used throughout the book and if you think you have your coding practices down to a fine art, read through this - you never know where you can learn a new thing or two. Also, if you are still one of the few out there that are not performing Unit Tests (shame on you) then just the first four pages of chapter 9 (p 121 - 124) should sell it to you, and your manager if required.

    Now the not so good! Maybe it’s because we are so much into ‘best’ practices that a few things niggled me.
    There are a few contradictions in the book. Not only where the advise to never leave commented out code in your application is ignored, but in some cases (e.g. p66) some Catch blocks with no code contain a comment as to why they are empty, while some are indeed completely empty (no comment) - we believe this is not a good practice and is one of the few cases where a comment is indeed useful in a block of code.

    I also found a paragraph of slight Utopia-ism (is that a real word?). It is mentioned that programmers should not just get the code working but successfully refine working code before they move onto the next piece of functionality. Unfortunately I know of no customer who would be willing to pay for someone to sit and refactor code when it is functionally working correctly. This may sound contradictory on a Code Quality site but i think it is the real world. I think a better way of arguing this point is to define what is meant when a piece of functionality is ‘done’. This would include the refinement (and documentation which is usually not evident) - maybe I’m just arguing semantics?

    In summary this book is a great resource of areas of good coding practices that each chapter has had many whole books dedicated to. I would like to see this book in Computer Science undergraduate courses as I feel to get these practices in early is only a good thing. For any professional, the information contained here in one book gives huge value to the reader.

    Tags: , ,

  • 19Nov

    In my last post I discussed some of the issues why Scrum projects were failing. One of the reasons expressed by the interviewees was that organizations are trying, but failing, to extend Scrum across the Enterprise.

    Scrum is, like other Agile methodologies, primarily aimed at development teams on a project by project basis and is difficult to extend. This is where Lean principles can help.

    A few organizations have noticed the natural paring of using Lean techniques to extend Scrum (or Agile) principles. One such organization is NetObjectives. Their ‘Scrum#’ methodology (their version of Scrum guided by Lean principles) helps to define the gap between bottom up Scrum practices and top down Lean principles to help other organizations successfully implement these practices across the enterprise.

    After reading their whitepaper on Scrum# I was intrigued to find out more. I caught up with Alan Shalloway (CEO of NetObjectives and a thought leader in this area) to discuss more about this and discuss several scenarios where Scrum# can be beneficial.

    As a side note, their resources site is one of the best I have come across with information regarding Lean and Scrum. Not only do they upload articles and papers frequently, but also include free previews of work in progress books they are planning to publish in the future.

    Tags: , , , ,

  • 18Oct

    At Agile and Development conferences this year some sessions have been looking at how to improve Agile techniques using failed projects as examples. Discussing some of these issues and reading blogs and articles it appears that a significant percentage of Scrum projects have failed and it is not quite the silver bullet many expected it to be.

    In this weeks video blog I asked some of the leading Scrum experts (Dan Rawsthorne, Alan Shalloway, Sanjiv Augustine and Ken Pugh) what they thought the most common reasons for failing Scrum projects is and what advice they can give to resolve this. In their opinion, it appears management and managing the Product Owner are currently areas to improve upon.

    I believe that many organizations that practice Agile techniques do not strictly follow Scrum, XP, Crystal or any of the other flavors of Agile directly, but instead adopt a hybrid ‘Agile-esque’ practice using parts of these methodologies that they feel work best for their projects. This was reiterated at Bob Martin’s keynote at Agile 2008 where he also stated that ‘Agile’ will be the term used as a practice rather than the umbrella for the individual practices such as Scrum, XP etc. Will this see an increase in Project success? Only time will tell.

    One opposing theory is; teams will adopt whatever practices they can implement easily and quickly to comply with senior management edicts so they can claim their organizations are ‘Agile’ (whatever that means to them?!?). The reality is, underneath they will really be working in a Waterfall manner with little change to project success.
    Such proponents of this theory will state that only by following the practices strictly, can you achieve project success repeatedly (as demonstrated by Menlo Innovations).

    Tags: , ,

  • 07Oct

    Fred Brooks’s law of ‘adding manpower to a late software project makes it later‘ is one most of us have tried to prove wrong…….and failed!
    I was at Agile 2008 and saw an interesting session, “Breaking Brooks’s Law” from Menlo Innovations, a Michigan based Java development company. They claimed to disprove this law and demonstrated their working environment and techniques that allowed them to do so.

    Although the presentation was only 45 minutes, we were in the room for almost 2 hours asking questions to determine how robust their techniques were, and to gain more insight into the conditions developers work under.
    Menlo’s results are based on a 3 year project that the customer had a deadline to demonstrate at a show. More features were required for the show than currently in the plan. So rather than re-prioritize, Menlo decided to add more developers to attempt to complete the work. They managed to complete the Project on time with all added functionality.

    The environment at Menlo is quite unique. All developers are co-located in the same large room (no offices or cubes) and pair program 100% of the time - they follow strict XP practices. A scheduling team determines which projects developers work on and who they pair with on a weekly basis. So developers work with different team members and possibly different projects every week.
    Also, as part of the contract, the customer comes to Menlo every week to prioritize the work for the next sprint.
    These techniques may appear somewhat draconian (for example 100% paring). I managed to catch up with the team and interview them to discuss this project further, bug rates, staff attrition rates and how Project Managers can push the message of pairing to Senior Managements/Directors (see video).

    I thoroughly enjoyed talking with the team from Menlo and they invite anyone passing by to stop in and take a look at how they operate. They also have an interview process which involves a large number of candidates performing a number of tasks including Pair Programming, with an appointment you can observe this too. A detailed paper about their techniques and contact details are here.

    Tags: , , , ,

  • 23Jul

    Chuck Allison’s interesting article “Software: Use At Your Own Risk”, (Better Software Magazine, July/August 2008, p. 9) discusses the risk inherent in software licenses compared to other warranties, reasons for the lack of quality in software and lists a sample of the code of ethics of the Association of Computer Machinery.

    Here are some reasons why I believe that the Government will not take effective measures to enforce more liability on software vendors in the short or long term (within the next 10 years).

    1. Consumers are instant gratification junkies. Consumers want things ‘now’ and are only mildly disappointed when they have small failings, so they do not officially complain so much as in other industries. We only have to look at the lines outside Apple Stores for the new iPhone to realize this. Many people were not even concerned that some phones had activation issues, as they understood that Apple would eventually fix this.

    2. No physical boundaries. License issues will differ in different countries and trying to enforce this will be an administrative and legal nightmare. Also, software can be downloaded from the Internet from anywhere. Even the attempted Chinese firewall was worked around within a day

    3. It is understood that software is never defect free. Maybe this is not the right attitude, however it is one we have ingrained into ourselves over the last 20 years as both users and developers. Microsoft’s famous Blue Screen of Death was frustrating for developers, but after a quick reboot, work continued – it was accepted (I say “accepted” as it was the most common OS used and there was no mass exodus to UNIX, or later Linux). Would the same attitude apply if your car broke down several times on your way to work?

    4. Software organizations do not learn. Many articles quote from references such as Brook’s ‘Mythical Man Month’. This book was written 30 years ago and many of the failings in Software Development back then still exist today. For example adding people to late running projects only makes them later.

    5. Perceived insignificant importance. We know the cost of failed software is in the billions, but other things in the public eye have happened to constantly keep this from being a primary concern. For example, The Gulf War, 9/11, Presidential elections, rising fuel prices and the current Fannie & Freddie crisis. Although software is involved everywhere the quality is not considered a public priority.

    One of the ethics Allison lists is “Contribute to society and human well-being”. Unfortunately, for Governments to pass legislation of the sort suggested by Allison, a monumental catastrophe will have to happen. We saw something along these lines with the introduction of Sarbanes-Oxley compliance following the Enron scandal. However, even if a plane were to crash due to software error, it is unlikely that even loss of life would be enough for the Government to pursue measures. In my opinion, the outcome would be that the airline and the manufacturer would have lawsuits filed against them, while the FAA and software producer would, at best, experience some bad press.

    Tags: , , ,

  • 15Jul

    Two of our recent blogs; The Misnomer of Best Practices and The Dreyfus Model are tied together nicely in this episode of Enerjy.tv by way of a conversation I had with Dan North of Thoughtworks.

    Dan regularly speaks and blogs about these topics and gives his views on where so called Best Practices should be in an organization and how they are used depending on your position on the Dreyfus Model. Dan gives examples of how developers use Best Practices when starting a new skill or position within a company and how these practices and rules diminish in importance and become a hindrance once skills levels rise towards the Expert level.

    Tags: , ,

  • 27Jun

    A large part of improving the quality of software is knowledge sharing (indeed it is one of the basic tenets of Lean). In most organizations when a bug is submitted it is usually delegated to the developer who wrote the original code.

    Paul Pagel’s blog discusses how his team tackles bugs in development and production.

    I especially liked:

    “[The Production Support Resource] seems a lot like a silo to me. Everyone should be able to do production support on any system. I should have to, because it is a perspective of the system that is important to have. In response to this, we came up with a system of triage. Each day of the week is assigned to a specific developer. If a support item comes up, it is the job of the triage developer to respond to the client/customer we are working on it.”

    This is such a simple way of sharing knowledge and keeping tedium away from a designated ‘support engineer’. However, managers may originally question this for several reasons including:

    1) A faster response time will occur if the original author fixes the bug. – This is short-term instant gratification. After a while the difference in time for a bug fix between developers (of similar skill level) will most likely be negligible.

    2) The author is an expert in that area. – This allows others to increase their skills knowledge, benefiting the entire team. What happens if the original author is out sick or even leaves the company?

    3) We’ve always had a designated Support Engineer, everyone knows who to go to. – This is a Command and Control’ management style and in most cases leads to lower team results. Managing by Facilitation and allowing the team to assign work themselves has proved more motivational to the team and resulted in higher quality artifacts.

    I strongly believe that this method is more beneficial to the team, evolving individual’s skills and ultimately benefits the customer.

    Tags: , ,

  • 17Jun

    The Dreyfus Model shows the 5 stages of skill acquisition possible through experience of a subject.

    Created by Hubert and Stuart Dreyfus in 1980 while researching AI, the model was popularized by Dr Patricia Benner in the mid Eighties in her work on the Nursing Crisis in the US. Over the last few years this model has been resurrected in the Software Industry, primarily by Andy Hunt of Pragmatic Programmer fame. 

    The graph shows that in the Software Industry (as with all subjects), most people achieve a level of ‘Absolute Beginner’ or ‘Competent’, with few moving to ‘Proficient’ and fewer to ‘Expert’. The graph also reflects that as you move up the model the need for rules and best practices diminishes to the point where they actually become a hindrance.

     dreyfus.gif

    With the huge shortfall in supply of Software Developers combined with the quality issues our industry faces, surely it is better to keep the small percentage of people at the top of this model rather than move them on to management? (As so often happens.)

    I caught up with Andy Hunt at the recent Better Software Conference to ask him to discuss this and explain further how this model applies to mentoring team members and where ‘best practices’ fit.

« Previous Entries   

Recent Comments