Saturday, May 13, 2017

Why do devs hate Agile?

Sadface-2017-05-13-08-40.jpg

Someone asked me this the other day: “Why do devs hate agile?” and as I worked through my answer I thought it worth writing down. There are three reasons I can think of but before we get to them…

First off, I don’t think all “devs do hate Agile”. Or rather, I don’t think the vast majority of them hate it - and hate is a very strong word. Sure some do, no doubt but all? A blanket “all devs hate” ? No.

I do think its is fashionable to slag agile off, and few do this better than the agile community themselves. And unfortunately like a lot of fashions once it gets started it catches on. Once dev A says “I hate Agile” then dev B thinks its cool to say it too, and dev C sees A and B doing it so joins in.

The ironic thing about all this is that Agile is the product of developers. In the beginning it was developers - like me - who saw that the classical way of doing things (write down what the customer wants, design it, plan it, code, it, etc.) didn’t work very well but noticed that the way most work actually happens (quick, code foo… O foo is not quite right change it, quick) was actually better.

I was inspired by Jim McCathy’s book Dynamics of Software Development. Jim was a developer, albeit a developer who had started managing other developers. It was that book that made me think “alternative ways are valid.”

Similar insights were occurring with developers all over the world - as they raced to fix Y2K using heavy weight processes. Some of these coders went on to become mildly famous: Kent Beck, Ward Cunningham and Martin Fowler for example.

And here in lies number #1 why “devs hate agile.”

Theft and imposition.

Agile was all about dev in the early days - especially XP. Just 10 years ago coders would say “I’d love to work Agile by my (project) manager won’t let me.” So we set about making Agile manager friendly, we expanded the business arguments for why Agile was good, and managers got it. Now you hear developers saying things like “My manager wants me to work agile but he doesn’t understand” or “My manager wants me to work agile but does’t help.”

In the beginning Agile was a bottom up movement. Now it is a top-down movement, change is imposed on people rather than people wanting to change.

That is wrong.

Making it worse is the fact that many of those imposing the change frequently fail to understand the change they are imposing or do not question their own thinking. Management thinking needs to change too - start with Software Development is Upside Down.

Reason #1: Agile is now an imposed change.

In my experience developers want to work Agile because true Agile allows them - no, demands - they do a quality job. Agile doesn’t deliver half the benefits it promises if organizations don’t pay attention to quality, that means their technical practices, thats what we used to call technical excellence. That means developers doing work that are proud of.

Namely “technical practices from XP”, specifically: simple design, relentless refactoring, test driven development (plus behaviour driven development), pair programming and things like face-to-face conversations and “story is a placeholder for a conversation.”

I’ll point the finger specifically at Scrum, and later Kanban, for not mandating these practices - something I did with Xanpan. Part of making agile acceptable to management was removing the words extreme and programming, and down playing the difference high quality can make.

Without these practices teams are driven harder to deliver something sooner and quality drops. As quality drops it gets more difficult to deliver anything in a short amount of time. Consequently more is demanded of coders, stress and tension rise and it is not fun.

Reason #2: Agile without technical quality makes developers lives worse.

I remember meeting some coders in Cambridge, almost the first thing they told me was “We hate Agile, our managers went on a Scrum course and have insisted we do it for months.” I quickly discovered that they were not doing any technical practices, as a result they were racking up more and more technical liabilities and making their own lives harder. Once I explained that they were missing the technical practices their attitude changed.

Now to the final reason, perhaps the big reason…

The Agile toolset is intended to help teams organize themselves, it is intended to make problems visible so they can be addressed and fixed. In the hands of people with the right attitude this is brilliant.

Teams don’t need a manager (although one may still be useful).

Teams can see problems.

And teams can fix problems.

But… the very same tools used by someone with the wrong attitude are a micro-managers dream.

Which micro-managers wouldn’t want everyone to give a status report at 9.00am every day?

Who wouldn’t want to see all work broken down to pieces for which NAMED individuals could be held accountable?

And why wouldn’t they want to make a shocked face and send a very clear “that is not acceptable” message every time an estimate was high?

Visibility becomes a tool of blame.

I once helped a team at an airline set up a Kanban board, instead of using it to see bottlenecks, problems and find opportunities to improve the managers concerned used it to assign blame, point fingers and demonstrate that nothing was happening because someone else wasn’t doing their job.

Reason #3: In the wrong hands the same Agile tools are very effective micromanagement tools.

Tuesday, May 09, 2017

Clinic: Product Owner/Manager question

An old product manager friend writes….

“Just started a new gig as senior product manager at blah blah blah

Discovering that scrum teams aren't organized around products but rather engineering components. For instance a product manager has to work with three different scrum teams:

- front end

- back end

- data science

This makes it hard for Product Managers to manage but I assume easier for engineering. I've not encountered this before. Thoughts?

At any given scrum meeting there may be two or more product managers, as opposed to a single product manager per scrum team.”

OK lets see…

The organization is horizontally organised, not good - we’re back to Conway’s Law. Getting anything of business value delivered is probably going to entail getting the front end team to do something, the back-end team to do something else, and then the data science team to do something…

Now it is possible that that is the way the work falls. Its just possible that a lot of the work falls inside one component, e.g. data science, and that alone delivers business benefit. If the majority of the work is like that then horizontal organization makes sense.

But, in my experience that is rarely the case, and your comments suggest this is true here too.

Think of it in user story terms: stories rarely relate to one function, you are far more likely to need a little bit from each functional team. No one team can complete a whole story, they need the other teams to do something.

This makes work for project manager types to do - has team A done their bit so team B can start and why aren’t team C talking to team A?

The approach normally advocated by agile folks is Vertical teams.

Each team should be staffed to delivered business value itself: if it needs a representative from each function then so be it, if team members need more training, or need permission to go into a different part of the code then make it so.

Horizontal organization is’t that uncommon, it is usually adopted on the grounds that you need specialists and specialists need to focus on one thing. While you may still need specialists you want people to cross boundaries and do be business priority driven.

Then there is the question of product managers and product owners, o not again…

In this context the product managers ARE the product owners. Pick up the Scrum book, replace every instance of “product owner” with “product manager” and things are clearer.

And it is OK to have multiple product people in the scrum meeting - by the way, when you say “Scrum Meeting” do you mean “Stand up” or “Planning” meeting? Either way it doesn’t matter, you can have two Product people in each.

The important thing, especially if you mean the planning meeting, is: the product people speak with one voice.

Perhaps they have a common backlog.

Perhaps they have a pre-planning meeting of their own to decide priorities.

Perhaps they divide the work up as Strategic Product Owner/Manager and Tactical Product Owner/Manager.

Perhaps they agree one looks at segment X and the other looks at segment Y and they compare notes.

However they do it they need to speak with one voice. They need to agree.

A more interesting question is: why do you even have two?

Do each focus on different markets? Different aspects of the product? Or different time-frames?

It is entirely possible that if you had two vertical teams instead of three horizontal teams that one PM feeds one team and the other PM feeds the other team. In between times they both get out and see customers and decide between themselves what the longer term strategy, tactics and plans are.

Wednesday, May 03, 2017

Heavy lifting is the easy bit

Swords1-2017-05-3-10-06.JPG

If you want to annoy me say something like “Building software should be like building a house…”. To say I’m not a fan of physical building metaphors is something of an understatement, but… I think I may have notice something.

Take that picture above, no they are not space rockets, they are swords.

The Sunday morning, for the first time in something over 35 years I engaged in making something out of wood, calling it carpentry is an extravagance, but my sons wants to do some sawing - and all boys should get to saw shouldn’t they?

Specifically they wanted some swords to play with, so out came the bench, out came the saw and… Not bad, I’m a real man! - I can make children’s toys!

Look closely at the swords and you will notice that down towards the handle they have a pair of “wings” - actually they are meant to be hand guards. This was a requirement I only discovered during construction when the older boy decided his should be different to the younger boy’s.

So yes, requirements change and expand when you build real things too. Especially when innovation and differentiation are in play.

When he asked for this I had no idea how I was going to do this. Rather than stop and work it out I thought “umm… maybe he’ll forget, maybe I’ll think of something” - and carried on working.

I did think of something, I realised that if I used the offcuts from the top I could create the desired effect. Now here is the lesson.

Constructing the first sword took about 20 minutes - without the “wings”. The second sword took less time, maybe 10 minutes - again without the “wings” - because I knew what I was doing.

The process went surprisingly smoothly and I discovered I remembered a lot of both my school woodwork and time in the garage with my own Dad.

But, then I started on the “wings”.

These small additions took the same amount of time again, perhaps even longer. I also got into a mess with nails, screws and ended up using wood glue. The beautiful smooth finish is now broken by a protruding nail.

Put this in software terms: it took less than half the total time to constructing the two basic products, building the infrastructure went smoothly. It was the additions and “nice to haves” - or rather the innovations - that took up most of the time and caused the greatest problems.

Last autumn I had builders in change my house. In the first three weeks the basic product was created: a physical wall was taken out, an external door bricked up, a window moved and the floor, electrics and plumbing ripped out. All the heavy lifting was done quite quickly.

Things slowed down, it took another three weeks to construct a new internal closet and lay a new floor.

It then took another six weeks to finish the plumbing, electrics, finish off the construction, fit a kitchen and decorate it.

See? The heavy lifting, the bit most visible, the bit which actually requires physical work is done quite quickly. It is the detailed work which goes slowly, probably because it requires attention to detail.

It was damn frustrating: the hard bit was done, the wall was gone, a steel beam installed, why wasn’t everything else just done? Maybe I should speak to the main guy and say “can we get more people in?” or “can’t we work in parallel now?”

Isn’t this like software?

I got Mimas up and running in a week or two but it took me another couple of months to get all the ins-and-outs working the way I wanted them too.

You can install a WordPress site, even with Magento, in half a day. But getting it styled right takes weeks.

You can build a rough bare bones app in a few days. But doing all the detail takes months.

And many efforts are so scared of heavy lifting the try to project manage it away and the project management becomes more than the real work.

The problem is: to those who are not doing the work - my kids watching me, me watching the builders, your customers watching you - the bit they expect to take time - the heavy lifting - is actually quick. It is the detail that is slow.

Writing this now it occurs to me that this is exact what happens with ERP systems. SAP, Microsoft and Oracle come along, install the basic ERP and it is there in a matter of days - hurray, all the hard work done! Just detail, mere “configuration” left to do. Except the configuration is detail and detail takes time.

Its also true of blogs. Blogs like this I can bang in a few minutes. I take far longer editing them.

Once again the world is upside down.

Monday, April 24, 2017

Continuous Digital - the new name for the #NoProjects book

ContinuousDigitalLight-2017-04-24-20-16.jpg

Regular readers will be familiar with my rants against projects and my posts about NoProjects - if not you have a lot of catching up to do: NoProjects Q&A, Beyond #NoProjects, the podcast with Tom Cagley, presentations and lots more. And as many readers will know I’ve been working on a #NoProjects book on Leanpub.

The book will soon reach a point where the content is there, code-complete if you like. (Yes there are some batch process and debugging todo, another story.) The book has reached a point where it has outgrown the #NoProjects moniker and needs a new name. The new name is: Continuous Digital.

Before I explain the name change something special for readers: I’ve set up a discount on LeanPub for Blog readers. Continuous Digital is available for just $5 for this, the last week of April. Use that link or the code AprilBlog.

Now why the name change?

#NoProjects is a great rallying cry and accurately sums up my feeling that in many environments the cost and difficulty of project management actually makes things worse not better. Simply removing it and letting people do work would be a big improvement.

But #NoProjects is also absolute, confrontational and doesn’t actually say what one should do which is a pretty big flaw. An alternative needs a name which isn’t “No”.

#NoProjects has been a necessary step in this evolution, once you relax the mindset that says “everything is, or should be, a project” you see the world differently. This is more than just adopting a product model - although there is a lot of that.

What becomes immediately obvious is that the idea of “Projects” is itself a model - hence why I refer to “the project model”. And the project model is not the only way of managing. Indeed, project management has not always existed, there was a time before “projects” and there will be a time after “projects.” I see evidence all the time that companies are backing away from the project model.

Many of this things project advocates want are entirely possible in an alternative model: goals, estimates, new developments, portfolio management, governance and deadlines to name a few. One of my aims with the book has been to show how these ideas can still work in an alternative model.

The thing I come back to again and again is: successful software lives, it is used and continues to change. Projects, by definition, end. Success is continuous.

(I tried the name BeyondProjects for a while but it didn’t catch on and it got confused with things that go on top of the project model like portfolio management and governance. ProjectLess was another suggestion but “Less” is already overworked as the name of an agile scaling framework and as a CSS preprocessor.)

Now think for a minute, the word “digital” is all around us: “Software is eating the world”, almost all start-ups are software technology based, legacy corporations are rushing to embrace new ways of working and operating.

Yes this is about developing software but it is more. 30 years ago really only software companies developed software as their product. Today every business is, or soon will be, a software based business. Hence the word Digital.

We stand at a point in time where business is changing. The term “digital” tries to capture this change.

As more and more companies rush to embrace digital business it is vital they leave behind the idea that software is ever done.

In business world being done is bad: if you walk into you local Walmart, Tesco or Aldi and the shelves are empty and the manager says “Well we sold everything so we are closing” it is bad.

If Ford and Toyota turn around and say “Everyone who wants a car has one so we are closing” its bad.

Business thrives on change. If a business is digital then the change is going to be digital.

Digital business needs an alternative model to projects. A model that actually matches their business and does not pretend everything will be done one day.

Continuous Digital sets out that a model. Please buy and enjoy the book, its not finished (yet).

Friday, April 21, 2017

Stating the obvious: Pre & Post conditions and TDD

WarningWindowCleanersLite-2017-04-21-15-54.jpg

Can you have an epiphany more than once?

Well I did. In early January - perhaps the result of all the Christmas drink - I had an epiphany and wrote this blog post. As I finished writing the post I realised I’d said it all before… Something old, Something new:

Requirements and Specifications.

Still, I think the message is worth repeating…

Back in the early 1990’s everything was better, the Cold War had ended, the world seem be fighting just wars, I was having fun at University and my lectures were convinced that formal methods - logic based VDM-SL to be specific - were the silver bullet to software development. And so I spent three years being schooled to write pre and post-conditions on every function I wrote.

Actually, this made sense to me at the time and I continued it long into my professional career. I still find it useful to think like this although I long ago gave up actually writing them as comments. That was one of the failings, if you just wrote them as comments then they aren’t enforceable and they can easily become another piece of documentation which doesn’t match the code.

An improvement to this, and the way I used to write a lot of C++ code was to use assert. So my code would look something like this:

std::list<std::string>

extract_reviewers(std::map<std::string, int> *votes_cast) {

        // pre

        assert(votes_cast != null)

        assert(!votes_cast.is_empty())

        

This was an improvement but you needed to execute the code to make it happen. And that meant powering up the whole system.

So today I’m writing some Python, and my app just crashed, and I looked at the code and its obvious that the function in question shouldn’t have been called. “Arh… there is a test I missed somewhere…”

And it dawned on me… probably again…

When I write a test for a function I’m writing executable pre and post conditions. Here is the code:

self.assertEquals(dedupvotes.retrieve_duplicate_report(self.c.key), None)report = dedupvotes.generate_duplicate_vote_report(self.c.key, 1)self.assertFalse(report.has_duplicates())voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One", VotingRound)voterecord.cast_new_vote(submission_keys[1], "Grisha", 2, "Two", VotingRound)self.assertFalse(report.has_duplicates())voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One", VotingRound)self.assertTrue(report.has_duplicates())

See?

In the test setup I setup the pre-conditions. I may even test them.

I call the function, generate_duplicate_vote_report, and I check what happens, the post conditions.

(OK, it is not the most polished code, the refactor step has yet to happen.)

What has happened here is that I’ve moved the policing of the pre and post conditions outside the function. In VDM the pre and posts were comments wrapped around some imaginary code. In C++ the asserts top-and-tailed the method, with TDD the pre-and-post it in a special function. And the test harness allows just that code to be tested.

I was always taught to write the pre and post conditions first. Indeed, in VDM there was no actual code so you could only write the pre and post conditions. In other words: I was writing the tests before the code.

And now I write this, I remember I have made the same point before. When I made this point before I was discussing TDD’s younger, but possibly wiser, brother, BDD. If you want to have a read it is Something old, Something new:

Requirements and Specifications. That essay is also included as an appendix to Little Book of Requirements and User Stories.

What does this prove?

Perhaps not a lot.

Or perhaps that TDD and BDD are the logical continuation of an old, 1970’s at least, approach. They have a longer lineage than is commonly recognised and that in turn increases their credibility.

It also reminds me of 1994 when I was working in the dungeon of a small company in Fulham. Myself and another programmer, Mark, were racing to deliver a C++ system to a client and save the company. We were writing test harnesses for our code and I was writing pre and post conditions. In retrospect his tests were better than mine, mine often needed a human key-press, I think his might have been added to the build to.

In retrospect too, we came perilously close to Test Driven Development but we didn’t think it was anything very special, we didn’t name it, we didn’t codify it and neither of use made much money out of it.

Wednesday, April 12, 2017

What does a CTO do?

CTO_Aspects-2017-04-12-08-48.jpg

The last few years have been good to me, I’ve enjoyed giving advice to teams and companies and helping people get started with better ways of working, ways of working which usually go by the name of “agile” but the name is the least important thing. But…

I’ve been questioning if I want to keep doing this. Like most of us do from time to time I’ve wonder if I need new challenge, if I should join something big, more continuity and… as you might guess from my posts on Mimas I’ve kind of missed being closer to building something.

From time-to-time people have suggested I take on a CTO role - and certainly my ego likes the idea, it sounds important! - but, seriously, I think I’d like to give it a go. But that leads me to a question of my own:

Just what does a CTO do?

This is something I’ve pondered before because while I’ve met a good few CTOs in my time I can’t really see a consistent pattern to describe what they do. Everyone knows what a CFO does, they look after the money so a CTO should “look after” the technology but… how do you do that?

Before I come up with even more questions lets try some answers.

First up, lets be clear, not all CTOs are code-centric. I know organization where the primary role of the CTO is to understand the technology domain and code - software - is secondary. Take telecoms for example, the CTO in a telecoms company may actually be an expert in telecoms technology. Software may well be something someone else looks after, although the two need to work closely.

Such examples seem to becoming less and less common, perhaps that is just another example of software eating the world. CTOs are increasingly about the code…

Some CTOs are programmers, some CTOs are the only programmer.

This view seems common with non-technical entrepreneurs and in job-adverts for start-up companies. Maybe it is because these companies can’t afford to pay senior salaries that they hand out grand job titles instead. Or maybe it is because the founders really don’t understand technology and anyone who can code looks like a god to them.

I worry about these companies because the attributes which make the first “CTO” attractive (code god willing to work for peanuts and therefore young and mortgage free) are most definitely not the attributes you want a CTO as the company grows.

CTOs should most definitely be able to code - even if this was sometime in the past. And many CTOs I know, and have know, do continue to code. That is good when they are part of a team.

A CTO is also in part an architect role - and hence they should code from time to time. The CTO may well be the Chief Architect or Chief Engineer although such a role is more about building shared understanding not mandating plans.

And since software design is a copy of organizational design the CTO needs to understand Conway’s Law and organizational form and structure. Organizational architecture is as important as software architecture, they are symbiotic.

Some CTOs have a lot of say in organizational structure. Many CTOs run the technology development group - all the programmers and testers, and possibly analysts and project managers, report to the CTO. As such the CTO is the Chief Technology Manager.

But not all CTOs do this. Some CTOs are actually further down the organization. And some CTOs leave the running of the technology group to someone else - the Vice President of Engineering or Director of Development. Again the CTO may work closely with this person but the CTO fills more of an advisor or expert role rather than a management role.

Such expert CTOs may well be on the board, they may well have the ear of the CEO but they leave the day-to-day operation of development to someone else. And some don’t, some are deep in the detail.

Perhaps as more businesses become truly digital, and technology and business become truly one, then CTOs running development operations will become less common and CTOs as experts will become the norm.

CTOs need to keep their finger firmly on the pulse of technology - what is happening, whats new, what is taking off, what is going down, what are Apple planning? And Amazon? And Microsoft?

But actually understanding the latest technology may well be less important than understanding how that technology changes business, changes competition, changes organization and structure. Manager-CTOs may well put that understanding directly into action but Expert-CTOs will educate others in the organization, from new recruits all the way up to the board.

CTOs also have a role in recruitment and forming the development culture. If CTOs think quality is important the engineering staff will take quality seriously. And if the CTO says, like one I knew once, “I’d rather it was on time with bugs than late and working” then every engineer will know within about 5 minutes.

While CTOs may not interview every candidate for a role they will certainly interview some of the key roles. More importantly the CTOs needs to work as a cheer-leader for the companies recruitment campaigns. Finding good engineers is hard, a CTO who gives the company a profile and makes it a place people want to work will help a lot.

CTOs often have a role to play too in sales. They are wheeled out to meet potential customers, talk technology and show the company takes the client seriously. When a company is R&D heavy the CTO doesn’t do much pre-sales but then the company makes a living selling products or services to other companies CTO as pre-sales is very important.

And it is perhaps at the highest levels, the board, the other CxOs, that the CTO role is unique. Almost by definition each CxO (Chief something Officer) is a specialist in their own field: the CFO knows about finance and the CMO knows about marketing. Although the CEO should be more of a generalist they come from another function so once upon a time where specialists. The COO (operations) may be another exception although this is often post held by the soon-to-be-CEO so it is a training post. (In my experience, the CSO role (chief strategy officer), when it exists is used to sideline someone before helping them leave).

In the CTO the other CxOs have a peer they can talk about the technology implications for their business. It is here that the CTO has the opportunity to influence the rest of the company and help them maximise the benefit of technology.

The common theme in all of this is the CTO leads the thinking of others. To use a rather over-used, and perhaps equally vague term, the CTO is a thought leader around technology. The CTO helps others in the organization understand not so much the technology itself as the implications of technology for the business. (And that implies the CTO needs to be a good communicator.)

That of course is provided the CTO has those opportunities, that they are at meetings and senior meetings, if “CTO” is simply a grand title for a programmer then they have little influence.

Summary

  • The title CTO should be reserved for roles which are more than just programming
  • A CTO should be able to code
  • A CTO should understand software architecture and will be one of the architects but probably not the only architect
  • The CTO needs a firm understanding of Conway’s Law
  • The CTO needs to understand organizational structure and play a role in designing the organization
  • Some CTOs are technology experts while some or powerful managers with their own department
  • CTOs need to keep abreast of the latest technology development
  • The CTO may well be the most senior pre-sales consultant in the business
  • More importantly the CTO need to understand the implications of technology and how business is changed by technology
  • A CTO helps to guide other company executives in their use and understanding of technology
  • Ultimately the CTO is a “thought leader” - they guide the thinking of others.

Given that it is pretty obvious that very few, if any, individuals can fill the role. Any CTO will inevitably be good at some things and not so good at others, as humans they will inevitably flawed.

And me?

Do I still want to be an CTO? - well yes but actually, I’m not concerned about the title, call me what you will - Chief Engineer is a title I’d love too - but what I’d love is a role which allows me span boundaries: as someone who understands technology, can code, can architect, knows how to align business with business structure and technology architecture; as someone who knows the importance of knowing what is being build will meet customer needs.

If you know of such a role I can always be tempted, until then, I’ll stick to consulting.

Monday, April 10, 2017

Mimas: What it does

My last entry I discussed some of the lessons I learned coding the Agile on the Beach submission and review system, Mimas (feel free to have a play). For completeness I’d like to tell you what the system does and what I want to do next for the system:

For the speaker….

What you get is a fairly basic form to submit a proposal. You receive an e-mail confirmation and at some later date notification of the outcome. You should also receive a link to the scoring and comments your submission received - that is, if the organiser wants to send it.

Before I go on, it is worth pointing out that Mimas is build around the assumption that conferences have tracks, e.g. software coding track, product design track, etc. Submissions are tied to a conference track, reviewers are asked to review all track submissions and final decisions are made on a track-by-track basis. Since tracks are configured when the conference is set up they are largely fixed. That could change in future but right now they are fixed.

For the reviewer…

Reviewers are assigned to one or more tracks and asked to review the submissions in the track. They get a list of all the submissions and for each one can score the submissions from -3 (don’t want) to +3 (really want.) That is round one. The conference organisers can then decide which submissions to shortlist for round two.

In round two reviewers are asked to rank the shortlisted submissions - from 1 at the top to… well however many are shortlisted, 5, 6, 10, 16 - whatever.

For organisers….

Creating a conference goes without saying! - They can configure it too: maximum number of submissions per speaker, max number of co-speakers, tracks, talk types and durations, expenses options, e-mail templates, e-mail ccs & bccs and a few other bits.

But all organisers are not equal. There is a permissions system which allows the conference creator can decide just what other organisers are allowed to see and do. They also get to decide who the reviewers are and assign them to tracks.

Most of what the organisers see are reports which slice and dice the submissions in different ways but those with the correct permissions can do some other things:

  • Move submissions between tracks
  • Review submissions and reviewer scores
  • Shortlist submissions from round one to round two
  • Decline and accept submissions
  • Export submissions data
  • Send bulk (personalised) e-mail to submitters
  • And of course change permissions for other organisers

What happens next?

There are two “big” changes I’d like to make…

I want to revise the way the system handles review so that rounds become configurable. Right now there are two rounds of reviews: one a scoring system, -3 to +3 and a second ranking round. I want to allow conference organisers to decide how many rounds of voting there should be and select the type of round they want. That will allow me to configure scoring (e.g. 0 to 5 instead of -3 to +3), add some more types of voting (e.g. multi-criteria), configure rounds and allow speakers to be anonymised.

The other big change, which comes from reviewer feedback, is to allow private comments. At the movement all reviewer comments on submissions are shared with submitters. But reviewers want the ability to make comments that are not shared.

This is a difficult one, I’d like reviewers to be open and share all their thoughts but some reviewers don’t like that. And because of that they find the system less useful. If I was Apple maybe I’d just say No, thats the way it is. But I’m not Apple and I need to meet client expectations.

Technically, I want to change the e-mail handling system, again. Although this is in its third version I’ve seen better ways of doing it. This is classic refactoring, each time I’ve change the way the e-mail system works I’ve seen a better way of doing it. Submitters and reviewers won’t see much change but improving the architecture will allow me to make enhancements more easily in future.

The other technical change I should make concerns testing. I really should look at ways to bring more of the UI under test - or at least run “bigger” tests. While there are lots of fine grained unit tests increasingly I find it necessary to manually test how the system hangs together, e.g. when I make changes to mail handling. This is because actions happen in the UI which cause quite a lot of stuff to happen below.

There are many more small changes I want to make to the system but they would probably take longer to describe than to write about!

So the last question is: is this worth while?

If the system is only ever for Agile on the Beach then probably not. It works.

If the system is used by other conferences then some of these changes, perhaps all, are worth doing. But then, maybe until I make those changes none will use it!

A classic dilemma.

If the system is my own little play thing then yes, all these changes are worth doing because I enjoy coding it! But enjoying doing something is different from it being commercially worth while. Financially I’m certainly better off doing something else. But if I value a hobby then it is worth doing.

Another classic dilemma.

One might ask: has it been worth doing so far?

Improved the AOTB submission and review process: Definitely!

Refreshed my programming: Yes

My own personal learnings: Yes

Created an option for others: Yes

Financial returns? No

Its just a shame that the first four don’t pay the bills!

Another classic problem.

Friday, April 07, 2017

10 Lessons from coding the Mimas conference submission & review system

MimasDesign-2017-04-7-16-56.jpg

The picture above is the documentation for Mimas, the conference submission and review system I wrote for Agile on the Beach. The documentation is three A4 sheets (2 state diagrams and one short paragraph of an assumption) plus an A3 object model - actually the database object model. All stuck to the wall in my office.

That is all the paper documentation, there are over 100 unit tests too which form pretty good documentation and have allowed me to continue changing the live system. There is also a physical stack of cards on my desk which form the backlog, although the most important changes I need to make are firmly logged in my brain.

A couple of my blogs have mentioned Mimas before but in this entry I just wanted to share some lessons about the system and my first serious programming effort in years.

For the record the system runs on the Google AppEngine, it uses standard Python AppEngine libraries, e.g. webapp2 plus a light coating of BootStrap on the UI - thanks to Sander Hoogendoom for that suggestion - and SendGrid for mail but apart from that is pretty much free of libraries. It comprises 8500 lines of Python including 3300 lines of test code. There are another 2400 lines of HTML which contains about a hundred lines of JavaScript. The JavaScript gave me an interesting insight…

I like to think I know Python but I don’t think I know JavaScript, the JavaScript I used here was 50% scrapheap challenge and 50% programming. On the few occasions I did anything more than a simple function I found I spent an inordinate amount of time getting it to work. I kept putting this down to not really knowing JavaScript - plus perhaps being a bit snobby about JavaScript not being “real” language.

But, fairly late in the process I realised why JavaScript took so much time and why Python was so fast: The Tests.

The Python was properly Unit Tested. When I needed new functionality in the server end I built it test first. And it just worked. Time and time again I surprised myself how quickly I got things working.

Not so in JavaScript, I kept avoiding it and when I did something it just took too long which made me dislike JavaScript all the more.

But… when I came to UI I’d let myself off about the unit tests. I never set up a test framework. And so I never unit tested my JavaScript either. I slowly, lately, realised a lot of my JavaScript mistakes would never have happened if I had unit tested it. And I’d also wager my UI development generally would have been faster if I had properly unit tested it. UI tests take longer, manual tests take longer, it takes longer to find out something doesn’t work and to try something else. Fail fast, fail cheap.

Lesson 1: Be even more honest with unit testing.

Lesson 2: Yes unit testing the UI is more difficult but that shouldn’t be an excuse for not trying.

To some degree I would defend myself by saying I was really new to JS and a lot of the webapp2 UI ideas and was just learning. But that begs the question: would I have learned faster with tests? At some point, before today, I think I would have done.

Although I didn’t unit test the front end I did keep a strict front-back division and pushed as much logic as I could not the back.

Lesson 3: I was already (subconsciously?) compensating for where I knew I was weak.

(By the way, Python support for mocking and stubbing is good but can someone in the Python community please document it properly? Its still a bit of magic too me.)

One of the reasons I avoided third party libraries was because of the time it took to get them working. Take dragular - for example, it is a JS drag and drop library which claims to be “so easy it hurts the brain.” I couldn’t get it to work.

I spent a couple of days with it. (I could really do with drag and drop in one part of the system).

Then I gave up and in a day knocked together a non-drag and drop alternative - not as good but it works.

Lesson 4: Even ready to use code libraries have learning curves, sometimes that learning curve is longer than doing it a different way. The cost of reuse.

Something else I relearned: those really trivial bits, the bits you easily convince yourself you don’t need to test? Like getters and setters.

Well, if you do the tests you may well find they were so trivial you didn’t pay attention and got them wrong.

Lesson 5: Unit testing the most trivial stuff can actually be the most valuable.

I say I relearned this because I learned it with a previous development a year or two back and comparing notes with James Lewis found he’d had a similar experience!

In general I’m impressed by the Google App Engine. There are some places I got stuck and a couple of things which just don’t seem to work or are not really good enough (__init__ constructors and NDB come to mind.)

Mail handling caused me a lot of problems. In some ways I can’t blame Google for this ‘cos their documents discourage you from using their own mail handling system. When I eventually did cut across to SendGrid not only was the change far easier than I expected but it also solved some other issues I had.

Lesson 6: Sometimes we resist changes which are actually good for us.

Live running the system caused surprisingly few problems. The only real problem we had in live was hitting a Google quota limit. It turned out this was a quota limit around mail sending and was eventually force the move to SendGrid.

But… The Google docs on quota limited a far from clear. Or rather, the Google diagnostics are far from clear. The logs told me I’d blown a quota but not which one. It took a lot of hunting, and some guesswork, to find it was mail - not the number of mail messages but the frequency. Even then I got it wrong because the Google quota allowances have changed over time, not only is a lot of old information still on the web but some of the limits aren’t clear or seem to contradict one another.

Lesson 7: Select may not be broken but sometimes it hard to know exactly what isn’t working.

Overall, I managed again to prove Hofstadter's law but in part that was because I enjoyed myself so much! Really, I’d forgotten how much fun coding, and seeing the code work, is. Quite possibly, I spent too much time coding last year and not enough doing paid work.

And perhaps, this is what non-coders don’t like about coders. They see programmers enjoying their work and they fear the programmers are doing more because they are enjoying themselves. And maybe, they are right. But that isn’t a reason to make programming miserable!

In the first few weeks of coding I kept a very sharp focus on “Only what do we need for Agile on the Beach” but at some point I let myself go and enabled it for other conferences. But at that point I actually found it easy to change the system because it had been built well and built with tests.

Lesson 8: It is really hard to keep a focus on just what you need for now

Lesson 9: If you focus on good engineering broadening it out will come naturally; if you focus on broadening it out you’ll forget the good engineering.

This made me wonder if I could work as a programmer again. I can still program but I’m under no illusions: I’d never get past the CV filtering let alone an interview. Firstly nobody would hire me because I haven’t commercially programmed for over ten years. But, more importantly I don’t have the libraries or other related technologies.

To pick a Python job at random, here is the one that came up first just now on JobServe:

+ Exceptional Python knowledge/experience

No, I’m not an exceptional Python programmer

+ Java, C/C++

My Java is very very rusty, my C++ just rusty but worse, I’m a C++98/2003 guy, I’ve no idea whats in 11 let alone 14.

+ Flask and/or Django

None

+ Agile, TDD, CI/CD

I’m rumoured to know a little about Agile, and a tiny bit about TDD but CI or CD… never really done it.

Fantasy over.

Lesson 10: Middle age ex-progammers may try to recapture their youth in code.

In my next entry I’ll say a thing or two about what Mimas does, but try it yourself. I’ve also set up a little site to publicise it - ConfReview.com.

Friday, March 31, 2017

Stockless Production from HP - a Kanban video

Some years ago when I was doing my masters degree I was shown a video called “Stockless Production” which was filmed at HP in the early 1980s. It was a brilliant illustration of Kanban, or Just In Time, or, as they liked to call it Stockless Production.

Its brilliant, the video quality is poor and the sound is even worse!



I few years later I found the video on the internet - it can be hard to track down. Although some experts exist elsewhere on YouTube I’ve never seen the whole thing there.

I often show the video as part of my work coaching and training teams. I use it either as part of a Kanban introduction or for teams already doing Agile a la Scrum to help them think about flow and quality.

Last year I paid to have subtitles added to the video. I’ve uploaded it to YouTube and in the hope that many more people can enjoy the film, have a little laugh and learn.

Many thanks to Brian Barnes at Osmium films for help with the subtitles.

A word on copyright: I’ve not made this available before because I have no idea about copyright. You can tell from the fashion (and lack of women managers) that this is at least 1981 and it is even conceivable its out of copyright.

I have made efforts to track the copyright down and failed. I believe that at some point the video - and copyright I guess - was passed from HP to Motorola University. I read somewhere that the video actually had an HP or Motorola part number. Given that the HP of this video no longer exists (it has split twice, first HP and Agilent, then HP into Hewlett Packard Enterprise and HP Inc.) and that Motorola no longer exists (and that it also split multiple times).

Saturday, March 25, 2017

AOTB 2017 - notes on submission selection & review

Phewww… Agile on the Beach isn’t for another 3 months but in one way its just ended for me. So it is a good time to share a few notes, specifically about speaker selection.

Background

My role in Agile on the Beach centres on the speakers. In the early days I hand picked the line-up but for the last 4 (or maybe 5) years we’ve run an open call for papers. I write the CfP, I run the CfP process, I talent spot (and encourage submissions), I respond to (potential) speaker queries, I run the review processes.

This year the CfP opened at the star of December and earlier this month we published the full line-up, so the majority of my work for the conference fell in that period. The majority of this blog will focus on our selection procedure and provide additional feedback for those who submitted.

Those of you who are thinking of attending AOTB 2017 will also get an insight into what happens behind the scenes. And anyone - all of you I hope! - who are thinking of submitting to a future Agile on the Beach or any other conference may well learn something useful.

Everyone who submitted should have notification by now - accept or decline, please let me know if you don’t. For those we didn’t accept I’ll shortly send an e-mail with more information on how your submission faired.

It helps to understand the AOTB review and voting procedure (a blog from couple of years back). This year I widened the scoring system from -2 to +2 to -3 to +3 in an effort to spread out the scores bit, I’m not sure it helped through.

Another change was the addition of four new reviewers who are not on the conference committee. This removed some of the workload from the committee and, I think, made for better reviews. It also meant that no submission had fewer than 4 reviews and some as many as 7.

The big public change to Agile on the Beach 2017 is a move from September to July - a move forced on us by changed in the academic calendar at Falmouth University. But behind the scenes our organization changes have been even bigger - partly because we had 3 months less to organise 2017.

One big change is Mimas - more information on my Conference Review mini-site.

After several years of an ad hoc system of managing reviews I bit the bullet last summer and created our own conference submission and review system. I’ll blog more about this soon but right now let me say, like every other software development it seemed to take longer than expected!

However it has massively simplified things. I think next year, with the system in place and far less work needed, my life will be better. But, it has been work - and I’m so glad I did it test first!

Anyway, what can I tell you about the submissions themselves and the reviews….

About the submissions and reviews

There were over 320 submissions from over 220 potential speakers. With so many submissions I’m worried that we will loose out on fresh voices, I’m also worried some of the true experts will be deterred from submitting.

For each track round 1 reviews reduced this to a shortlist. For each track we decided a cut-off score, submissions which scored above this were on the shortlist and those below marked for decline.

We then did a double check, there were several sessions below the cut-off which held promise - e.g. interesting speaker or a novel topic - which we added to the short list. We specifically looked at all the submissions which didn’t make the cut-off but had been given a 3 score (the highest possible) by at least one reviewer. Most of these were then included on the shortlist as well.

And one or two, certainly no more, which were removed from the shortlist.

We also moved a few sessions between tracks in both rounds when we thought they were better in another track. But, with so many submissions we rely on those submitting to make intelligent choices on which track is most appropriate.

For 2017 the track shortlist cut-off score was:

  • Agile Business, 60 submissions, 9 speaking slow, shortlist threshold score: 8
  • Agile Practices, 57 submissions, 4 single slots available, shortlist threshold: 8
  • Product Design, 22 submissions, 4 single slots available, shortlist threshold: 7
  • Product Management, 38 submissions, 5 single slots available, shortlist threshold: 6
  • Team work, 83 submissions, 5 single slots available, shortlist threshold: 7
  • Software Delivery, 54 submissions, 9 single slots available, shortlist threshold: 9

(When a double is chosen then two single slots are combined.)

I was particularly happy to see more submissions in the Software Delivery track this year.

We had lots of very strong submissions from very strong, experienced, speakers. There are a few names we’ve declined this year who I find it hard to believe we said no: Judith, Karl and Steve spring to mind.

We also had quite a few weak submissions were the potential speaker only gave a few words of synopsis and biography - some even left the bio blank. I marked a lot of submissions down because the synopsis and/or bio did’t really say much. Some of these weren’t much more than a title and a list of bullet points.

Now quantity shouldn’t be a substitute for quality, less is more and so on, but… in a number of cases there wasn’t enough information to make a judgement so the submission was marked down. It also puts a question in my mind as to how interested the speaker is: I’m probably investing more time in reading and thinking about the proposal than they put into writing it.

If you want to speak the competition is fierce. You need to put really effort and thought into you submission.

Of course some synopsis go the other way and are too long, you bore before you get to the end. Similarly for biographies, not too much but not too little either.

Some synopsis spend all their time talking about the problem they will examine and said very little about the solution. Others seem to jump into solution without saying why - that is particularly true of talks which involve a brand-name tool or technique. (Sessions dealing with specific tools, especially commercial tools, are seldom scored highly by AOTB reviewers.)

There is an art to writing a synopsis: describe the problem (not in too much detail) and say something about the solution (without giving it all away), while at the same time being engaging and leaving the reader wanting to know more.

A few speakers - all from the USA interestingly - didn’t seem to read the call for papers. They requested speaking fees and/or proposed sessions which didn’t match our topic areas. I wonder if some people just fire off submissions to every conference?

To be clear: we don’t pay speakers.

We do sometimes give keynotes honorariums but we choose the keynotes, we don’t ask for keynotes in the open submission system. Normally we have already agreed our keynotes before the we call for speakers.

(If you know of someone you think would be a good keynote for AOTB please drop me a mail.)

As always those who requested long-haul airfare tended to get marked down. We don’t set a budget for speakers but we do keep an eye on costs, we have paid long-haul fares on occasions in the past but we can’t afford to pay many. This year both our keynotes are long-haul.

I can’t see any way around this. Its unfair but is a genuine constraint.

This year we did offer speakers the option of paying their own long-haul airfare and we would pay in country travel costs.

And similarly double sessions tended to get marked down. Again unfair but hard to avoid. We are aware of this problem and we do create some doubles space (the bonus track) but it is still a trade-off.

This year we seemed to have a lot of talks about “mechanical scrum” and “failing Agile”. Maybe this is a sign that Agile has come of age. These sessions didn’t score highly largely because they spent most of the synopsis setting out the problem rather than discussing solutions.

Failing Agile is well… a fact of life. It is only interesting when we can learn something from it - something not to do, or something to do differently, something to prevent or rectify the failure.

What will I want to do differently next year?

  • I hope to add a few more independent reviewers.
  • I’m thinking of designating track leads for reviews, these will weed out the clearly unsuitable submissions and help with the shortlisting.
  • Mimas will have a few tweaks but for AOTB it is essentially done.

So advice for those anyone thinking of submitting in future:

  • Read our Call for Papers: yes, I know it is long but we give a lot of information
  • Choose your track carefully: your changes of selection are much better if you submit into one of the more specific tracks (Software Delivery, Product Design and Product Management) rather than the three more general tracks (Business, Practices, and Teams.)
  • Put some effort into the synopsis, especially the short synopsis, tell us a bit about the problem but not too much, and tell us something about what you are going to say. The long synopsis isn’t as important but is useful for giving more detail.
  • Don’t take “long” synopsis as literally, it does not need to be very long. If you have a strong short synopsis then just leave long blank.
  • Watch your timings: some speakers gave detailed timing breakdowns (to the minute), on the whole these aren’t believable and people got marked down. However some speakers were just too ambitious in their contend and reviewers didn’t believe they could cover it all.
  • Double sessions really need to be outstanding, and they need to be interactive. No lecture based double has ever been selected.

I hope some of that is helpful to at least some of you.