Eric Lefevre-Ardant on Java & Agile

September 10, 2009

Interviewed by François Beauregard

Filed under: agile, agile2009 — Eric Lefevre-Ardant @ 10:55 pm

François Beauregard from Pyxis Technologies interviewed me during Agile 2009 for their Vox Agile podcast. The interview is now online.

Toy sampling megaphone

We chatted about a favorite topic of mine: how to expand the horizons for Agile. My point is mostly that the Agile crowd is mostly talking about basic issues in software development, including during the Agile 2009 conference. I fear that this my give the wrong impression to beginners (”how, so we only need to do this and that, and we’re agile? Cool!”) and even to seasoned practitioners (”this Agile thing is not addressing my needs anymore”).
I would much prefer that we talk more about complex problems, whether they relate directly to Agile or not. This can include technical discussions or more touchy-feely ones. As long as we are addressing difficult problems, we will be making progress.

I also want to see more cross-domains talks. Obvious domains are the heavy industry (I won’t need to remind how influential Toyota has been to the IT industry) or performing arts. But that could also include things such as Behavioral Economics.

Or not. I don’t know for sure. However, I do know that we should be taking more risks. And stop presenting Introductions to Retrospectives for the upteenth time.

At the end of the talk, I mention 2 things for further reading. Here they are, plus a bonus book that I’ve just read:

The podcast is available in French on the Vox Agile site. Here is a direct link to the MP3 file.

Tim Harford

June 2, 2009

“Is Scrum Evil?” Beyond our session at XP Day Paris

Filed under: scrum, xpday — Eric Lefevre-Ardant @ 12:14 pm

Is Scrum Evil?Our session “Is Scrum Evil?” at XP Day Paris this year went well. Attendance was good (50 people or so). One participant called it an “eye opener“. Two recorded the discussion (one of the records is available, in French, here; look for the podcast published on May 30th 2009). Nicolas Martignole even did a transcript of the session (in French — you might want to check out the Google translation).

I thought I would give more details here.

Our goals

We didn’t exactly manipulate the participants, but we certainly did not reveal, on purpose, what our goals were:

  • help dissenting voices come out of the closet — very few people are vocally criticizing Scrum today in France, and I have found no blogs. I wanted to show the pro-Scrum side that they do not have the final word.
  • let people vent — both pros and antis
  • make participants think — one later came to me and suggested that I should have offered “alternative solutions”. Well, I have none (though I do have some starting points, see below)Is Scrum Evil?

Alternative endings

We had prepare additional materials, in case the discussion died out. Fortunately, it was so lively that we couldnt use them at all. You’ll find all three of them below.

You are not alone

The first thing I wanted to highlight is that, though dissenting voices on Scrum (or Agile) are not currently heard in France, they do exist in the rest of the world:

Is Scrum Evil?

Scrum has Crossed The Chasm

There is a model that give hints to the current situation with Scrum. It is the Technology Adoption Life-Cycle, as amended by Geoffrey Moore in his seminal book “Crossing The Chasm“.

In short, it appears that many of the arguments against Scrum do not just mean that it is poorly explained, nor just that it is poorly understood, but rather that it is now being adopted by a large number of people. Or, to rephrase this, that it has been (consciously or not) packaged in order to be palatable to the mainstream. This implies trainings, books, consulting services, explanations, case studies, success stories. In short, packaging the approach just like a marketing team would do. That the people behind Scrum did it on purpose (as I believe) is beyond the point: the Agile approach that wins the hearts and minds of IT professionals everywhere is necessarily the one that comes with such as package, a whole product, in the words of Moore.

That is a reality that people that are blindly against Scrum must acknowledge.

ARXTA

Finally, I would like to point any aspiring Scrum-evil-ist to Brian Marick’s writing on Agile roots. His argument is that “Agile” (and, I guess, the names of pretty much all Agile methodologies) is too easy a term to adopt. In other words, many people will look at the name, glance at the practices, and quickly come to the conclusion that “hey, this is exactly what we’ve been doing all along! Let’s avoid asking ourselves hard questions and let’s not change the way we work.” Which is, obviously, missing the whole point.

Brian has came up with a new name for the roots of Agile: “Artisanal Retro-Futurism, crossed with Team-Scale Anarcho-Syndicalism.” The name is cryptic (and even slightly repulsing) on purpose, so that people will have to ask, and will have to have a conversation.

Further reading

Check out

March 10, 2009

Refactoring applied to features (or YAGNIAM – You Aren’t Gonna Need It… Any More)

Filed under: agile, misc — Eric Lefevre-Ardant @ 1:52 pm

Taking OffRefactoring code without modifying its external behavior is necessary to keep your code base manageable. That is nowadays a well-established fact.

However, it can only go so far to prevent your code base from swelling permanently. In theory, if your revenues keep growing, you can keep recruiting more people in your development team, and all will be good. Unforunately, that’s not usually how software works.

Like many other things in life, software goes through well-known phases: birth, growth, maturity, and decay. At some point, the costs of maintaining the software are just not justified anymore and the editor pulls the plug.

However, we can do a little better than that. If the project still has some life in it, it can be a better plan to reduce its complexity, in order to lower its maintainance costs and increase its life. In fact, there is no need to wait for the product to decrease in popularity. Housekeeping should be done as early as possible in the lifecycle. No need to maintain features that cost more than they pay.

My current customer has exactly this problem. Their project suffers from feature creep. Regression tests become more and more costly to maintain (it is actually planned to delete some of them regularly — though, of course, nobody really knows which ones we can afford to throw away).

I would call the activity I’m promoting “Feature Refactoring: the process of changing a computer program’s list of features (and corresponding code) without modifying revenues significantly” (balancing short- and long- term revenues). This means that it is OK to remove some features, as long as it is acceptable to your customer base, in terms of money to make in the long term. Basically, you want to avoid the classic pattern where 80% features that are little used or not used at all.

Note that I am not merely talking about features representing significant weight in terms of code, tests, or documentation. Rather, I want to target anything that costs money to maintain, understand (for new hires), market, etc.

How can we do this? Well, here are a few smells that can help

  • your client representative tell you about it — the easy scenario
  • you detect that few customers actually use your modules – monitoring tools can help you here
  • you find bugs in production… and few people actually complain about it — should this feature be there at all?
  • you upgrade your project… and nobody complains — if your features are popular, someone is bound to complain about any change
  • specs for a particular feature are not updated — features that do not evolve tend to rot
  • run workshops with customers — a interesting format for this is Speed Boat

My point is that there are even more potential benefits in term of code maintenance when removing features, compared to refactoring the code base (which is a good thing to do, too).

Refactor your features. See this one there in the corner? You Aren’t Going to Need It.

You’ll be happier.  And you will probably save money.

January 17, 2009

Agile Alliance Meeting in Paris

Filed under: agile — Eric Lefevre-Ardant @ 12:36 pm

Hall

As you might know, the AA board is meeting in person a couple of times a year and, for once, they decided to reach out to the crowd. This time, it happened in Paris.

Not much talking that evening; mostly networking, really. I got to talk to a few people that I had seen at Agile 2008, but couldn’t meet, because of the huge crowd. It’s too bad I couldn’t stay for drinks, since I was giving a training the following day.

Check out my pictures.

November 3, 2008

30,000 ScrumMasters and 1,500,000 members of Scrum Teams?!

Filed under: scrum — Eric Lefevre-Ardant @ 7:17 pm

A look on the ScrumAlliance list of Certified ScrumMasters shows that they have 618 pages each containing 50 names of ScrumMaster. This means more than 30,000 CSMs as of Novembre, 3rd, 2008.

According to an interview of Jeff Sutherland, for every CSM, there are 10 Scrum teams that have not had training.  That is, 300,000 Scrum teams.

Finally, Scrum defines that a team is made of 7 people, give or take 2. Taking the conservative value of 5, this means that we have 1,500,000 people doing Scrum.

One and a half million?! Is it really possible? That said, even taking more conservative numbers, there is no doubt that many people are using (trying to use?) Scrum. The annual Agile Survey showed that more than 60% of agile projects are using Scrum, or Scrum combined with XP.

To be honest, this is probably off the mark but maybe not by an order of magnitude. Some estimates put the number of developers worldwide to something between 8 to 13 millions. I’d be surprised that even 5% of developers worldwide are using Scrum (400,000 to 650,000 individuals), but the 1,500,000 figure contains all people in a scrum team, including some that probably do not qualify as developers, such as business analysts, testers, graphical designers, etc. So it could work.

At least it would explain why many people now start to think that Scrum Is Evil.

October 21, 2008

More about Coding Dojo at CITCON Amsterdam

Filed under: citcon, tdd — Eric Lefevre-Ardant @ 9:52 pm

As a nice followup to my earlier post, Willem did a great write up of our Coding Dojo session at CITCON Europe, in early October. His post is supplemented with pictures by Marc.

October 20, 2008

Valtech Days are tomorrow!

Filed under: conferences, hudson, openspace, valtech — Eric Lefevre-Ardant @ 10:44 am

Valtech Days are starting tomorrow! We are all very excited.

I will be presenting 3 things:

  • Retrospectives: the key to continuous improvement, together with Laurent Bossavit
  • A 15-mins demonstration of Hudson
  • Introduction to the Open Space part of the conference
If you will be attending this conference, please come and say hi!

October 13, 2008

Valtech Days: bio & abstract for Jeff McKenna

Filed under: agile, conferences, valtech — Eric Lefevre-Ardant @ 9:09 am

Jeff McKenna will be opening the Valtech Days conference on October 21th with a keynote on Agile. We got his bio in English, as well as the abstract for his talk. We duly translated into French, but could not take immediate advantage of the English version.

I thought it would be a good idea to reproduce that version here. The French version is on the conference website.

Talk: Agile: Crossing the Chasm

Description: Agile Software Development is moving to a new level of acceptance in the industry. Geoffrey Moore has famously called this transition Crossing the Chasm. As this occurs, a number of significant changes in the rate and manner of acceptance of Agile are happening. These changes are often accompanied by legends, myths and other points of view. Some of them support the new point of view while others discount it. The keynote will explore many of the legends and myths that surround Agile and describe techniques for adoption Agile into the modern enterprise.

Jeff McKenna has been involved in software development for over 45 years and has been actively participating in the creation and delivery of agile software development since 1987. He has been involved in all areas of software product development from programming, system design and architecture to project management, testing, sales and marketing. Since the late 1980s Jeff has focused on the process side of development and along with Jeff Sutherland and John Scumniotales at Easel corporation in 1993 created the Scrum methodology of agile software development and started the very first Scrum team.

Jeff has worked extensively with object-oriented programming systems, languages and applications and was the Chair of OOPSLA in 1994 which helped to incubate and increase adoption of several related disciplines including agile software development. Working with IBM, Cigna, ObjectShare, Easel Corp, Millennium Pharmaceutical and the US Air force, Jeff provided expertise in architecture, design and implementation for their first Smalltalk based object-oriented projects.

As an Architect at Rational Software (now IBM), Jeff made various contributions to Rational’s industry leading Rose product. These included extensions to the Unified Modeling Language (UML) to support a UML model of testing. Jeff also worked with industry pioneers, including Grady Booch, to extend the Rational Rose product to natively support Design Patterns.

Jeff is a Certified Scrum Coach and Scrum Master, he has taught, coached and mentored agile teams using Scrum and Extreme Programming practices for many companies, including Oracle, PayPal, Borland, Vanguard, Microsoft, Google, Lockheed Martin, Tumbleweed Communications, V-Mark and Net Objectives.

Jeff is currently an Agile evangelist for Serena Software helping to build Serena Agile On Demand and working with customers and partners aiding the adoption of agile methods and practices in engineering organizations.

October 8, 2008

Coding Dojo on Legacy Code

Filed under: citcon, facilitation, tdd — Eric Lefevre-Ardant @ 5:31 pm

At CITCON Amsterdam last WE, Willem van den Ende and I facilitate a Coding Dojo session on both Mockito and Legacy Code.

Willem and I thought that we had missed some of our goals (especially demonstrating Mockito), but still many people at the closing session mentioned that they enjoyed it :-)

Coding Dojo with Legacy CodeWe tried to prepare a bit before diving into the session. However, in practice, it became a bit chaotic, as many participants tried to make their opinion heard. This was very different than when I do that in trainings or even at Valtech. I guess this is because there were quite a few people (~20) and most of them were rather experienced and strong-headed (I guess they wouldn’t be at such a conference otherwise!).

Coding Dojo with Legacy CodeWe managed to have a quick retrospective at the end. Here are some of the things we learnt:

  • We need to prepare the session better; half of the session was spent fixing an existing bug in the original application, instead of adding features. Also, Willem wanted to take advantage of Mockito, which was quickly forgotten as people concentrated on fixing the bug.
  • At first, do Safe Refactorings (the ones that can be done automatically by Eclipse and such tools), though you still need to be careful of what you are doing
  • It is OK to add code, not OK not remove code from the legacy application
  • Add collaborators using setters to facilitate testing
  • However, be careful: getters and setters can quickly get out of hand
  • Singletons are bad, not just because they make code hard to test, but also because they create secret coupling
  • Apparently, many (bad) coders want to write singletons and static methods (which are both frown upon in the context of testing), simply because they do not want to type the ‘new’ keyword
  • We could try to rotate the copilot on a longer basis (for example, every 10 mins, instead of every 5 mins for the coder)
  • I (Eric) got concerned that the Coding Dojo format prevents participants from thinking; facilitating the session sometimes seemed to be like herding cats
  • it was clear that many people was interested in working on legacy code
  • in the end, a Coding Dojo with an appropriately complex application seemed like a good way to learn about handling legacy code
  • I need to experiment a bit more with Coding Dojo for Legacy Code, but I feel that the format is rather good. Next year, we’ll do better!

    October 7, 2008

    Is Scrum Evil?

    Filed under: citcon, scrum — Eric Lefevre-Ardant @ 6:46 pm

    This was a fascinating discussion facilitated by Jeffrey at CITCON Amsterdam. Much talking with him followed, so I think I finally understand why he introduced this topic, and why so many people seemed to dislike Scrum.

    This was a typical discussion where antis are much more vocal that pros. When Jeffrey asked who thought Scrum was evil, maybe 12 raised their hands. Only 3 or 4 (including me) thought that Scrum was NOT evil. The majority stayed silent.

    Most of the session was spent listing arguments pro and anti Scrum. You could say it was lively ;-)

    Is Scrum Evil? session“Scrum is evil because…” (I am not saying that I agree with all of them…)

  • when it fails, all the people involved think that all of agile is no good (it poisons the well for agile)
  • it values process over people
  • it is pyramid scheme (Scrum Trainers are supposed to be certified)
  • it causes some pointless standups (not all are pointless, though)
  • it is iterative waterfall
  • of the term ‘ScrumMaster
  • some people limit their view of agile to Scrum (they do not look into agile engineering practices)
  • some people feel it will solve all problems
  • it is sometimes used as a dogma (’this is not Scrum!’)
  • Is Scrum Evil? session“Scrum is good because…” (I am generally OK with them)

  • it provides structure for engineers and product owners
  • it makes agile acceptable to managers
  • of the concept of a ‘Product Owner’
  • it makes self-organizing teams respectable
  • it makes people reponsible for their commitment
  • it is easy to adopt
  • it makes more people talk
  • it puts emphasis on delivery
  • it exposes problems earlier
  • it popularized short iterations
  • it is a foot in the door for agile
  • The first conclusion of the session to me was that the people against Scrum were mostly complaining about the fact that some projects were failing with Scrum.
    Further, I feel that this reveals that they are in a post-agile mindset, which could be more prevalent in the US/UK (maybe the Netherlands, too?) than in France where Agile still faces an uphill battle.
    Another thing is that, when you look at it, the people were really complaining about its success. After all, many of these arguments (pyramid scheme, some people feeling it solves all problems) were the very reasons Scrum was successful.

    Closing sessionAs Jeffrey pointed out during the session, it meant that, as per described in Crossing The Chasm, we are simply moving from the ‘enthusiasts’ stage to the ‘early adopters’. Many more people are now using Scrum, and its message is bound to be altered somewhat.
    Jeffrey further pointed that, since it seems that 80% of projects fail now that many are using Scrum, just as there were 80% of projects that failed before, it simply means that 80% of the population is just not very competent. It has little to do with the methodology. This is also what Alistair Cockburn meant when he mentioned that “Process is a second-order effect”.

    So, my undertanding is that Jeffrey’s goal is to change people and to use tools such as psychology to do so.

    I am more nuanced, maybe because I am living in a country were Agile is still not being widely accepted. After all, this is all a short-term vs. long-term thing. Having a manager doing Command & Control was very short term. Agile (and Scrum) is medium term: you are providing a tool for people to get better in the medium term, if they are competent enough. Changing people is much longer-term thing. It might take years, generations, or may not ever happen.

    For me, Scrum still seems to be providing those medium-term benefits, at least for now, in my environment. When it won’t be the case anymore, I might bash it like everyone else does.

    Update (07/10/08): changed title from “Scrum is evil!” to “Is Scrum Evil?”

    October 1, 2008

    Upcoming Talk: Introduction To Scrum

    Filed under: agile, conferences — Eric Lefevre-Ardant @ 9:13 am

    I will be at Agile Tour Grenoble Thursday next week. My talk will be an Introduction to Scrum. Come if you are interested in getting the basics about Scrum.

    In the meantime, Agile Tour Besançon is just starting today! Then, we’ll have Muhlouse, Geneva, Grenoble, Lille, Toulouse, and finally Valence.

    Check out the official Agile Tour website (in French).

    Next Talk: TDD Training

    Filed under: tdd, valtech — Eric Lefevre-Ardant @ 9:04 am

    I am giving a 3-day TDD training session at Valtech Training premises, from Monday, October 6th. I’ll introduce a Coding Dojo, like we did in the TDD training last week.

    September 28, 2008

    Improvised Coding Dojo

    Filed under: tdd, valtech — Eric Lefevre-Ardant @ 11:50 am

    Coding Dojo at AgileOpen 2007In the past three days, I have taught Test-Driven Development to a group of Java developers in Brittany. I thought it was a good idea to arrange an inpromptu Coding Dojo. That contained a moderate risk, as all dojos I knew of were attented by volunteers.

    It turned out very well. Though one or two participants managed to check their emails at some point during the session, most were paying attention at all times.

    A couple of things to remember for future dojos:

     

    • In the past, I have usually attented dojos were either everyone was in front of a computer (either coding or co-piloting), or a single pair was coding in front of the others. After watching Dave Nicolette and Ryan Hoegg facilitate a dojo where all got to code in front of the public at Agile 2008, I thought this was a good way to get participants to do their best, plus let others to read code with a watchful eye.
    • A participant mentionned that the exercice helped him realize that names for test methods were very important. Yay!
    • For first-timers, always start with a very, very simple exercice. We did the dictionary kata (given a collection of words, find all words in a String that are not in the collection). We managed to complete it satisfactorily in 2x 30 minutes.
    • We did our best to run through the code Test First, writing the tests with as little prior thinking as possible. That said, one participant suggested that pairs should talk a little before doing so, in order to get the pair to bond better. Sounds like a good suggestion, though it would probably require more time than what we had available.

     

    All in all, I am happy with the outcome. We should include it in our course curriculum.

    July 31, 2008

    A4 Reports as Iteration Reports

    Filed under: agile, scrum, valtech — Eric Lefevre-Ardant @ 10:25 pm

    Many people have asked me to talk about the A4 Reports that I have introduced on one of our projects. I’ve postponed this for a look time, but I finally got around to do it.

    The idea came from the book Toyota Way, by Jeffrey Liker. At the beginning of the book, the author warns the reader against a classic trap: after reading about the success met by Toyota, many want to implement their practices verbatim. Well, my philosophy is that, if I got only one useful practice from the book, then it was worth paying for ;-)

    So anyway, the author is telling about the fact that Toyota employees do “A3 Reports”. The idea is that, when there is a problem, after careful thinking, the people in charge produce a report that fit on an A3 page. The reason for this constraint is that 1) is it quick to read, 2) it can be faxed around the company with the fax machines they have.

    Another thing is that they tell about the problem and the solution using Plan-Do-Check-Act (PDCA). Which means that their reports typically contain:

    • a description of the problem
    • an overview of the possible solutions, including options that were later discarded
    • a description of the implementation of the solution on a limited scale (Plan & Do)
    • a description of what needs to be monitored, and milestones (Check)
    • if the solution is proving a success, a description of the implementation company-wide (Act)

    I was personally attracted to the reports, because they force the writer to keep the information concise, though readable. Graphs were good too, as long as they make the contents clearer to the reader.

    My personal problem was that, as a ScrumMaster, I have to produce reports every time we complete an iteration. The reports are boring to write, probably boring to read, and they were getting longer as the various stakeholders regularly demanded that I add more information. Other metrics that had to be maintained included productivity, progress on project, etc. I felt that these metrics were not very useful and I had also been getting into arguments with my boss’ boss, especially after a steering committee where it had become clear that I couldn’t make the situation easily understandable to our clients, even with an Excel document containing 6 sheets. So I was feeling some pressure to show goodwill, and to produce something that was actually useful.

    One day, my direct boss demanded that I produce not only my usual textual report (generally 2-page long), but also a 10-slide PowerPoint presentation. I was underwhelmed, since I already felt my report was not that useful. I got her, though, to agree that, in addition to what she wanted, it’d be worth trying those shorter reports.

    I set myself the following constraints:

    • must fit on a single A4 sheet, as this was the only format of paper supported by our printers
    • character size must stay at 12 points for normal text; text that was part of graphs just had to be “as readable as I could make it”

    The result for the first Sprint to have an A4 report is the following (in French):

    End of Sprint 12 Report - A4 Report

    Things of note:

    • the 3 columns; they are the key to fit as much text as possible when you have many bullet points
    • the charts, especially the burndown chart. This was the first time I managed to show the burndown chart in a readable fashion in a report to people external to the team.
    • the content, which is made largely by the information gathered during the iteration retrospective

    When my boss saw this report, she was delighted. It became the main document discussed during steering committees between the various stakeholders, including the CEO of the company. I also sticked it to the walls of the development room, in full colors.

    In later iterations, I refined the report a bit, but it stayed largely the same. For a few iterations, I had a tendency to change the charts, depending on the situation (for example, if speed of development was an issue, I’d add a chart showing the number of actual work days per iteration). I have found that it was not as necessary in later iterations. Probably a good thing, as I would not be able to gather all the data necessary.

    Here is how it looked in a recent iteration (in French again, so it might be hard to figure out what each box is for):

    End of Sprint 16 Report - A4 Report

    How I build the report:

    • The report is built using Excel. Some charts come from external sources, such as the burndown chart which I extract from the Google Spreadsheet-based Sprint Backlog; an issue is that, being images, they are hard to redimension. Other charts come from separate Excel files, which is a bit annoying as Excel suggests pulling data from the other Excel files every time I open the report. Finally, some charts are made from data that are hard-coded in the same Excel file, such as velocity and code coverage.
    • A lot of information is actually coming from the Sprint Retrospective. I can prepare a few things before the retrospective (mostly the charts) but much of the data is mined from what was learned during the retropective.
    • I spend quite some time adjusting the boxes on the sheet. The best way I’ve found is to use drawing features from Excel that let you perfectly align or center elements together. Still, it takes significant time to clean up at the end.

    For your information, here is a list of the noxes used in the last report. You will want to adapt this to your needs:

    • Sprint Number & Dates
    • Implemented Features
    • Features that Were Not Implemented
    • Important Facts from the Sprint
    • Burndown Chart; this is now coming from a Google Spreadsheet ;-)
    • Statistics on bugs
    • Things We Could Improve Upon
    • Things We Are Happy About
    • Actions For Next Sprint
    • Project Trends
    • Velocity
    • Overall Progress on Project
    • Overall Bug Statistics
    • Code Coverage By Tests

    I hope all this will help. Let me know your improvements on my design!

    July 30, 2008

    Agile 2008: My presentations are bigger than yours

    Filed under: agile, agile2008, valtech — Eric Lefevre-Ardant @ 2:06 pm

    With Agile 2008 just around the corner, superlatives abound: “largest Agile conference in the world“, “premier international conference in agile development“, “a production team of highly respected Agile experts“, “spans the whole spectrum of agile practice“.

    Participating companies are also guilty of that.

    One such is SolutionIQ, who boasts “more speakers than any other services organization in attendance“. I have counted 9 speakers and 9 presentations on their page.

    Well, at Valtech, we have “only” 8 presenters, plus one organizer (yours truly): Greg Hutchings, Gilles Mantel, Dave Nicolette, Ryan Hoegg, Mark Smith, Andrew Rendell, Alan Goerner and Tim Walker. But they will host a total of 12 presentations:

    So, there! ;-)

    Older Posts »

    Powered by WordPress