Agile : The Circuit

Ohm’s law defines the relationship between the voltage, current, and resistance in an electric circuit: i = v/r. The current is directly proportional to the voltage and inversely proportional to the resistance.

Agile from a business perspective is all about zoning in on what it is that is really required to offer the highest business benefit, in the shortest space of time, a.k.a. finding your Minimum Viable Product (MVP).

There can be a lot of ceremony in Agile, I get the impression that this is what takes the front seat in people’s minds, particularly those that would consider themselves “non-technical”.

Agile, to a Developer, should be about far more than just daily Stand-ups and Retrospectives.  Agile is a mindset and an approach, focusing on improvement, reducing your resistance.

It’s vital that any improvement you identify gets fed back into future sprints, like electrons flying round a circuit, this is what keeps the lights on.

Your backlog is your potential, like a battery, keep this topped up with ideas, both business, and technical and you will be able to run indefinitely.

Your voltage (potential difference), is what you can achieve between your two fixed points, start and end of the sprint; with your throughput, current, being everything you can potentially achieve, relative to your impedance.

As responsible Developers, we should be maximising output, and identifying and feeding back on anything that can possibly reduce our resistance.  Sure there will be no surprises here, but:

  • Improving build/deployment processes can help greatly, with DevOps as a discipline justifiably being huge business now;
  • Refactoring our code can make it more malleable and open to change, again another Agile principle, see Software Craftsmanship;
  • Scope changes mid-sprint can be a huge impact to output, this may not be fully understood by business owners, it’s important to feed this back, we would know about it if we waste their time, the opposite should also hold true (communication, and a good rapport is key here!).

Think about what you can do within your team to reduce your resistance and increase your output.  Talk it through with your peers and make a list of improvements you’d like to make, over time it’ll make your bulb glow brighter.

Development Team Membership : Part 2 – Apologies

A lot of people struggle with apologising.  It can be difficult, particularly in the workplace, but apologising even for little things can make a big difference to those around you.  Couple of really obvious examples:

Sorry, I broke the build

Sorry, I’m not going to meet this deadline

Now, it’s not likely you will need to apologise very often; in fact, if you are, it’s probably indicative of a wider issue. In the above examples, maybe you need some coaching on TDD from peers, or maybe you need to be empowered to push back on an imposed deadline.  There will be occasion, however, when things don’t quite go to plan and you just have to hold your hands up and say “Sorry”.

Apologising shows ownership and responsibility for your actions, which for me have always been key qualities with respect to choosing who I want to work with.  Those with “Teflon Shoulders” tend not to last very long.  It also shows a respect for your peers, they will know you dropped the ball, denying it will do you no favours in the long run and a prompt apology can make all the difference in getting people on side to help with a resolution if needs be.

What is an apology?

To me, an apology has very little to do with what it is being apologised for.

What’s done is done, no point crying over spilled milk, and so on.

In fact, in my head, I’ve probably already moved on…

Time Travel
Time Travel

So, what is it?

To me, an apology is:

  • a contract of intent not to make the same mistake again;
  • a display of ownership of your actions;
  • respect.

Not apologising, is the opposite:

  • a contract of intent to make the same mistake again;
  • shirking ownership of your actions;
  • disrespectful.

Sincerity

An insincere apology is worse than no apology, if you don’t mean it, don’t say it.

Closing Thoughts

It’s rarely too late to apologise, (especially if you still have a job!).  Apologising can help you get something off your chest and also have a profound impact on those around you and the way they act towards you.

Is there anything you’ve done and shrugged off into the Ether?

Next time you do something a little bit questionable, at work or outside (we all do, don’t deny it), apologise and see where it gets you.

 

Development Team Membership : Part 1 – Moaning

I recently made the transition from Permanent Employment to the world of IT Contracting.  Along with this change, came a different role for me with my new client; a much more hands on position writing a lot more code which is exactly where I wanted to be!

I previously wrote a series of Blog Posts providing tips for Development Team Leadership, this has dried up of late due to my change in circumstance, however I would like to now start sharing some tips for Development Team Membership, having worked on both sides of the fence.

Don’t moan without a resolution

Moaning is great.  Everyone loves a good moan, myself included.  Moaning can be helpful and healthy, in fact indirectly it’s part of the agile feedback loop, what went well, what didn’t.  Accompanying this, should always be next steps; how to negate what grievances you may have.

There’s definitely a right time and a place for moaning sharing your observations in the context of your team, you’ll be best placed to know when this is, but it may typically be a team retrospective, a workshop on where your team is heading or a one on one, planned or impromptu session with your mentor/lead.

As a software professional, keep it impersonal.  You won’t want to come across as a bully, picking out specific people’s faults or shortcomings is never helpful.  Code reviews should be used to increase code quality, but be cognisant of their feelings and how you may be perceived.

Mr Muscle, loves the jobs you hate

You can’t always have the glamorous roles in the team, sometimes you just need to roll up your sleeves and get stuck in.  As a good team player you should have no qualms in doing the grunt work.  Grunt work leads to insight, and insight can lead to improvement in process.  Developers are lazy, and that’s no bad thing.  Do something once, do something twice and automate.

Don't skip Leg Day
Don’t skip Leg Day

Don’t shy away from hard work.

Improvements Log

You’re the one with the low level knowledge of your application(s), any potential improvements that don’t fit within the confines of the piece you’re working on should be logged, to be addressed at an appropriate time.

This will serve to broaden the teams understanding of how they should all be writing software, e.g. coding standards/patterns, and, in the same way that code reviews serve to manage quality going in to an application.  Improvements serve to keep the application up to date.  As soon as it’s committed, code becomes legacy, it’s a valuable resource and an opportunity to improve, it, and yourself as time passes.

An improvements log can serve as a satisfying alternative to a good rant.  Log it and move on, your lead should be monitoring the situation and pushing things forward.

Development Team Leadership First Steps : Part 12

Bugs

Despite what your boss might like to think, Bugs are a fact of Software.  There’s a number of things you can do to minimise the occurrence, the severity and the impact bugs might have, mostly centring around having a reliable set of Unit Tests.  Regardless of your best efforts, they will still find a way through the net, it’s how you handle them that matters.

Be Honest

My first piece of advice would be to be honest about them, and the root cause, however embarrassing to you or your team it might be.  It’ll be too late to cover it up, so don’t waste your time thinking of excuses.  Get to the root cause and come up with a plan to resolve it.  If it’s a major problem in Production it’ll be on your shoulders to come up with a strategy to expedite a resolution. Continue reading “Development Team Leadership First Steps : Part 12”

Review : The Software Craftsman by Sandro Mancuso

The term Software Craftsmanship seems to be rather divisive in its support, with, as mentioned in the book numerous times (along with retorts) the fact that the movement can come across as elitist.  At it’s core it’s another manifesto, a fairly open-ended one at that, but having read the book it extends far beyond this.

In much the same way as Agile, in the pure sense, is more of a mindset than a prescriptive set of rules, the ideas behind Software Craftsmanship conveyed in the book really lean towards achieving excellence, building on and complementing a lot of the practices outlined under XP and Agile.

The Software Craftsman

Continue reading “Review : The Software Craftsman by Sandro Mancuso”

Development Team Leadership : First Steps Part 10

Don’t take requirements on Face Value

Often your requirements can overstep outlining the business need and into murky waters of business users defining technical solutions; which are rarely the way we would choose to do it, or in some cases even technically feasible.

“Has the world gone mad; or is it me?” – Ben Howard

As professionals it’s our obligation to probe these requirements until we’re left with something that makes sense that all parties are happy with.  It’s always worth asking why, sometimes a requirement can disappear altogether as a result.

This isn’t doing yourself out of work, it’s enabling you to do the “right” work, this is mutually beneficial; we’re paid not only to write software but to provide a service, probing will prove your understanding of the business and ultimately build trust.

Bigger Picture

Make sure you understand how the component you are writing fits in with the architecture as a whole.  As the Development Lead you’ll be expected to be capable of participating in conversation with all areas of your team and all levels of the business, from those with a vested interest in a particular piece of functionality, all the way up to those who aren’t interested in the minutiae, just the fact that the system works.

If you don’t understand how your software fits in with the wider Organisation you won’t be able to fulfil this.  Again, if you can prove your understanding you’ll gain trust, but it’ll also enable you to more conclusively understand requirements if you understand for example what impact your validation (or lack of!) may have on downstream systems.

Are we there yet?

You’ll inevitably be asked (“probably” by Project Managers, and “probably” numerous times) whether you’ve finished a Task, it’s nice to have an answer to hand about not only your own work, but that of the team.  Having a visible board to track progress on is really part of the Agile process, having one of these can ease the pressure, (but that doesn’t mean you won’t be asked!).

Not only is it good to have an answer to questions, but if you have an idea of whether your team is likely to finish all of the tasks on your current sprint then it will allow you to raise the alarm early, or re-prioritise workload within the team.

 

Development Team Leadership : First Steps Part 9

Identify Bottlenecks

It’s important to be able to take a top down view of your team and it’s bottlenecks, internal and external.

Bottle Neck
Bottle Neck

External

For example, the inputs to your sprints “should” be nailed down when planning, you might need:

  • a data model definition;
  • web service schema;
  • validation use cases;

…the list goes on.

If they consistently aren’t appearing on time, this is a bottleneck hampering your productivity.  It’s important to raise the alarm. Continue reading “Development Team Leadership : First Steps Part 9”