Showing posts with label principles. Show all posts
Showing posts with label principles. Show all posts

Sunday, April 02, 2017

Todo – doing – done is not “Starting with what you do now”

A couple of weeks ago I had this discussion about the Kanban principle “Start with what you do now” and whether or not that is the same as the “todo - doing - done”-value stream we know from personal Kanban.

Thinking that the two are the same is actually a very common misunderstanding.
”Start with what you do” now has nothing to do with “todo - doing – done” and actually predates personal Kanban by a couple of years. Todo-doing-done is a simplified concept that Jim Benson introduced to use the Kanban Method on a personal level. In Kanban terminology those boards are referred to as "proto kanban" – systems that might evolve into kanban systems.

"Start with what you do now" refers to the big difference in the approach. While in approaches like XP, FDD, DSDM or Scrum, you implement a whole new process, the Kanban Method’s approach is to model what you do now. In the Kanban system.

By simply stating todo-doing-done one does not yet model the way the actual team works.
Since the general workflow "todo – doing – done" is always true, there is not yet the connection to the way your team has agreed to work and no way to discuss specific process policies.

Facilitating the evolution of this very general approach to a system that captures how your team wants to work, and building the peer-accountability that is necessary, is one of the challenges for everyone guiding or coaching evolutionary improvement processes.

till next time
  Michael Mahlberg

Sunday, July 21, 2013

The term conflict is vastly misunderstood

"We never have any conflict in our team"!

For me that is a really, really sad sentence. I really love to work with teams without quarreling and bickering – but I very much hope that there is conflict.

The meaning of conflict

What is `conflict´ after all? According to the english Wiktionary conflict is:

Noun conflict (plural conflicts)

  1. A clash or disagreement, often violent, between two opposing groups or individuals.
    [...]
  2. An incompatibility, as of two things that cannot be simultaneously fulfilled.
    [...]

And while almost everybody thinks about the first interpretation, the second one is equally valid and extremely valuable to recognize.

It's all about managing conflict - and that's a good thing

This is yet another thing that popped up when Tom and I prepared our hand on Agile and lean practices course - a lot of the techniques in lean and Agile are there just to handle conflicts in a reasonably civilized way:

  • We prioritize work-items because they are competing for development time - there is a conflict for the time
  • We queue deployments - there is a conflict for the deployment machine
  • We use A3 reporting to point out conflicting interests.
  • etc.

Recognizing conflict is an enabler

Without recognizing conflicting interests as such there is no way to resolve the conflict - take the original idea behind (non-automated) continuous integration: Software developers in the nineteen-nineties realized that they ended up with incongruent systems, when they all just committed their work to a central repository whenever they had a working result.
Apart from testing mechanisms and some other technical details, there was also a hidden conflict - the conflict for exclusive access to the system for modification. Recognizing this conflict enables people to find solutions. In the original example from Kent Beck, integration happened only on one machine, thus mediating the conflicting request for access to the system by queueing them. Denying this conflict on the other hand prevents solutions.
(Or this denial leads into misguided attempts on Jidoka like continuous integration servers which should really be called build servers and more often then not are just used as a fig-leave ... but that is another story – which will be up here shortly).

Conflict, there's just no way around it…

…but there are many ways to handle it wisely - by applying tools and techniques to resolve or manage it. As with change in the subtitle of the first eXtreme Programming (XP) book, fighting it only makes it worse. In XP they say "embrace change" - the same is true for conflict if handled responsibly "embrace conflict".

Monday, April 18, 2011

Why Google-Checkout sucks - at least for me

I just tried to buy the electronic version of David J. Anderson's Kanban book, because I'm traveling the world quite a bit right now, left the paper book at home and wanted to look up a few specifics for the design my own personal kanban system.

Two things delayed my decision to buy it - and actually will delay it for a couple of days to come. Which is unbelievable for a process that takes a mere minute on amazon and the pragmatic bookshelf.

1) I have to buy the eBook twice to read it in iBooks and on the Kindle [see below]
2) I have to become a Google-Checkout Customer (which is the dealbreaker)

The Problems with Google-Checkout

  • They (Google Checkout) added my credit card info to the currently logged in google account
    Really? The currently logged in account? That's just silly.
  • They (Google Checkout) stored the credit card information
Actually Amazon also stores the credit card data. But amazon is a store - Google is a search engine and an information broker. So I'm supposed to give my credit card information to an information broker, who adds new services to it's portfolio every day?
So, what I'll have to do now - to get the electronic version of a book I already own - is to get a prepaid credit card, put some money on it, connect that to google checkout, buy the book, disconnect the card from google-checkout.
[Aka: No, I don't want others to be able to control my credit card and identity management. That's where I really want a push system]
What a waste of time!

The Problem with buying the book twice


I use the Kindle for reading and the iPad for Browsing, and since the Kindle UI is only mediocre compared to iBooks I would love two have both formats available as it is possible with the pragmatic bookshelf. I admit that the Kindle UI is not as bad on the iPad as it is on the Kindle itself, but still it's a drawback compared to the iBook experience. So the current option for buying the book online isn't "quite" as pleasant as it would be to buy it from the pragmatic bookshelf - or perhaps I'm just spoiled by the latter's focus on customer value.

Wednesday, September 30, 2009

Is emergent design possible? (I think it is!)

Just the other day I had a discussion with a really experienced lead developer about the feasibility of the no-big-design-up-front-approach and the necessary circumstances to make emergent design work.
Along comes these series of articles from Abby Fichtner that I stumbled upon last night.
And although there's more to emergent design than Bob Martins SOLID principles I think these articles make an excellent starting point for a deeper discussion of the subject.

Cheerio
MM

Sunday, August 23, 2009

How many Backlogs do you need?

Hmm... there used to be two backlogs in scrum IIRC:
the product backlog, owned by the Product Owner and the sprint backlog owned by the team.

Nowadays, scanning through contemporary tweets and blog entries, there are at least (in various amounts)

  • Product Backlog
  • Sprint Backlog
  • Impediment Backlog
  • Technical Debt Backlog

So I wondered: Do we really need them?
Right now my answer would be "Yes" and actually I think most of us use them already - albeit more or less secluded.

Of course the Product Backlog and the Sprint Backlog are completely visible all the time.

The Impediment Backlog and the Technical Debt Backlog OTOH are not quite as popular - mostly because we "should not have them" in the first place. If all "impediments are resolved within 24 hours" and "technical debt is paid back before a task is completed (aka Done)" and we "leave everything cleaner than we found it" both "Backlogs" are more like personal lists with a lifespan of less than a day.

Unfortunately reality is slightly different in lots of places and so we should recognize this fact and install corresponding backlogs with a fitting set of attributes.

So, what could these attributes be?

For the Impediment Backlog I'll try:

The usual stuff:

  • ID (Yes, I need an ID - but YMMV )
  • Synopsis (An understandable but very short description of the impediment that can be scribbled during the standup meeting )
  • Description (A longer description, that explains the impediment to the non-initiated)
  • Date created (well...)

The specific stuff for the impediment backlog:
(All of these should be considered optional and used as growing lists - just to make sure the impediment gets the attention it deserves)

  • Number of Mentions (A counter - implemented e.g. as a tally chart on index cards - to determine if the impediment is really such an impediment as it first seemed)
  • People affected
  • Tasks affected
  • Stories affected
  • area(s) affected (e.g. Specs, Tests, Coding, Deployment, Design etc.)

For the Technical Debt Backlog I'll go with…

The usual stuff (what did you expect?):

  • ID (Yes, I still need an ID - but YMMV still )
  • Synopsis (An understandable but very short description of the dept imposed than can be scribbled during coding or the standup meeting without much of an interruption)
  • Description (A longer description, that explains the debt and its effects to the non-initiated, probably written later)
  • Date created (well...)

The specific stuff for the technical debt backlog:

  • Area affected (e.g. Architecture, Design, Delivery, Deployment, Stability etc.)

Hmm.. that's not so much - I wonder if the list will grow over time.
I'd expect some of the TDB (technical debt backlog) to turn into tasks eventually, but they might also vanish simply because of DoD (definition of done), "no broken windows", "leave everything cleaner than we found it" and other related practices.
I wonder if it would be possible to derive the interest rate of technical debt... but that's quite another story.

Monday, September 29, 2008

scm & build: Levels of configuration

Here's the first little part of the (to be - or not -) series on configuration management and build management.

Although I wanted to start with some clarification on "Task level commits" I actually concentrated on different levels of configuration in a build environment. Here we go...

The levels of configuration

One of the biggest differentiators between a one-man-show and a team-effort-project are the different levels of configuration that have to be managed – and this is also a point where the quality of the whole build process can be heavily influenced.

Basically – unless the application-to-be is monolithic – there are four levels of abstraction: Machine dependent, user dependent, purpose dependent and (last but not least) project specific configurations. Each of this has to be managed separately and consciously to avoid (to much) manual intervention. Talking about indirection let me cite (once again) David Wheeler to whom the phrase “Any problem in computer science can be solved with another layer of indirection. ” is attributed. As he stated in the second part – which is often omitted – “[But] this usually leads to another problem” so let's have a look at the relative pros and cons of this fine distinction. To start of lets examine each level a bit closer.

Remarks:

By the way: Of course there are at least two Dimensions involved in this topic as well: run-time configuration and build time configuration. For the sake of this argument I'll postpone this discussion towards the [[build]] topic.

Purpose dependent configuration

Let's start with the purpose dependent configuration since this is a concern covered in most modern environments. The purpose I'm talking about is also known as build type or target environment or something similar to that. Typical purposes are “Test”, “Debug”, “Release” or – a bit less frequent – “Integration”. Depending on the purpose of the build there usually are a number of things that differ. For “Test” there might be some hard-wired shortcut to circumvent server-roundtrips or a “don't really send to printer”-entry or some other special behaviour that is meant to make testing easier (or even possible) without imposing side-effects on already installed systems. If you're building for “Debug” – one of the most commonly differentiated purposes – you'll certainly want to include debug information into your code, something you probably don't want to ship (although that could be disputed, but that is another story). “Release” of course is the purpose with which you build the shippable product once all test and QA-work has been done. The necessity of an “Integration” purpose arises only in projects where you need to integrate several sub-products and usually has rather project-specific configuration needs.

And of course there are some things (e.g. logging) that need to be configured differently for each of these levels. But speaking of logging we encounter another type of configuration that should not be mixed with the purpose specific configuration: the project specific configuration of components. While I'll go deeper into those in the next paragraph, the important part with respect to things like logging is to be aware of the fact that some thing have both – a project specific configuration and a purpose specific one. Trying to manage both in the same way can create real nightmares (I guess, everybody who has tried to keep Log4J configuration files useful for an extended period of time without that conceptual distinction knows what I'm talking about)

Project specific configuration

This usually is the first configuration option you come across. Almost any project nowadays uses some reusable libraries. Those of course have to be adapted to the specific needs of the project and thus the first level of configuration indirection comes into existence.

Although these configurations are applicable on many levels – from configuration information specifying a windows' layout to the much mentioned log-file configurations – at least they have a clear association. They are “just another kind of source code” and thus relatively easy to handle.

Machine dependent configuration

This one strikes as soon as there is even one more developer! The path which used to point at /usr/bin has to point to /usr/local/bin, the drive for intermediates that used to be C: has to be E: and the monitor resolution goes from 1024x768 to 1600x1050. Consequently some things have to be configured somehow – and here we definitely need a distinction between build-time and run-time.

User dependent configuration

The distinction between user dependent configuration and machine dependent configuration is a bit hard to make in a time where the correlation of people:machine moved from n:1 to 1:n. But even now – where lot's of people have more than one computer the real relationship is more like n:m since some computers are still shared. Especially build and integration machines are prone to sharing. Now, even on the same machine, the configuration might differ in paths, desired screen resolutions and mounted network shares, so there is basically the same set of configuration information as there is in the machine dependent part, but it needs to be managed in a separate space.

To summarize: We have the purpose specific configuration which is a central [[build]] topic, the project dependent configuration that correlates to source code, the machine dependent configuration that correlates to hardware configuration management, and the user specific configuration that somehow correlates to profile information. All of these should have traceable connections to identify possible configuration errors.

After I have raised all these questions of course I should also answer them – I'll do so some time in the future and will provide a follow-up link in this post...

I think that even the concept to have different levels of configuration enables people to create more stable build environments.

Cheers
_MM_

Monday, September 15, 2008

Build-, Version-, Configuration- and Sourcecodemanagement,

Lately I found myself talking about buildmanagement and configuration management a lot. And since this blog lies deserted in the wild anyway I think this is the perfect place to ramble about that stuff so I can point other at some more ressources than I can right now. (And of course other can point me to my own ramblings if I get lost in the discussion)

Topics I’d like to discuss (although this probably wont ever come to an end) include simple, practical, down to earth things like
  • The simplest way to set up svn to work with xcode for a small workgroup
  • How to set up (any) DVCS for XCode
  • How does SCM-integration work in XCode
but also things that seem to be intuitive to some but controversial to others
  • Command line builds
  • To branch or not to branch
and more conceptual topics (the most important to me) as
  • Releases, Versions, Variants and other “Numbers”
  • What is Multi-Dimensional SCM
  • Staging and promoting 

Stay tuned for the first episode in about a week (and nudge me if I havent published it in two weeks!)

Cheers
_MM_

Saturday, August 25, 2007

Divas and Geniuses

In a blog entry from the start of the week Mark Masterson cited from the lessons learned document of a past project:


"Change the design / architecture to reduce reliance on the divas"


That reminds me of a former client of mine who used to say
"If you've got a genius in the team - get rid of him"


At first that's rather sad, but after a while - and with changing responsibilities - I came to realise that there can be situations (actually lots of them) where the advise is absolutely sensible.



It can be sensible because most developers are of average capabilities!
After all - that is exactly what average means.
Therefore the probability to have "above average" developers declines with the size of the project (and the organisation) simply because of the definition of average.
Even if all (or at least almost all) the developers in a certain team are "above average" (e.g. compared to some outside group of reference developers) most of them will - by definition - be of average skill within the team. That's where the "get rid of the genius" sets in.



If one of the persons on the team is way ahead of all the others - lets say she is a specialist in compiler construction - their advantage can become a disadvantage for the team as a whole. For those "geniuses" TSTTMPW (The Simplest Thing That Might Possibly Work) probably is quite different from the things the rest of the team perceives as "simple".

Configuration files are a good example - while plain text with very little syntax is the "simple" thing for most of us a specialist in compiler construction wouldn't mind using a sytax that is "syntactically a little richer" to gain simpler implementation. He might end up with a configuration language like sudoers' - where guides to the grammar (defined in EBNF) and the grammar's grammar are provided in the manual pages just to give the average user a chance to understand sodoers.


Actually I worked on a compiler project myself way back in the 80ies and used to be kind of fluent in BNF, but figuring out sudoers still took me a while. And judging by the amount of

<username> ALL=(ALL) ALL

(basically: allow <username> to do everything he wants as root)


that I've seen on other peoples Macs not many of them go to great depth deciphering the format...



Back to projects: Of course the idea to get rid of every smart person in the team would not be the best option - unless you want the project to fail.

But the "geniuses" - or, to be fair: those who have advanced knowledge and/or experience compared to the rest of the team - have to be handled carefully. Only for very isolated tasks they should be left to work it out all alone.

For the rest of their work they ought to work closely together with other team members as long as their personality allows them to adopt their ideas to a level thats appropriate for the whole team. Should the latter not be an option then option one is valid again of course - the team should get rid of 'em.

But in my experience that is seldom necessary Most geniuses are quite willing to agree on a sensible level of "simple" as long as their is a sensible discussion.

So after all it no so sad anymore. The bottom line of my job is not to get the "best" possible solution but to make the team as a whole as effective as possible



_MM_

Sunday, August 19, 2007

Contracting Principles by Gerald Weinberg

I may not agree with everything he said, but the principles lined out by Jerry in his post on how to prevent consulting misery are a good starting point for everybody who is trying to figure out how to shape their relationships with their clients in a healthy way.

Friday, July 06, 2007

From Cavedrawings to Hyroglyphs to Times New Roman - and back to Cavedrawings.

Sometimes I don't understand our business...
Just recently I listened to an interview with Grady Booch where he (once again) emphasized that he never intended the UML to be used for programming (i.e. as a programming language).
I‘m a proponent of visual modeling myself and after experiencing the method wars of the nineties I'm glad that such a thing as the UML unifies the meaning of arrowheads, boxes and dashed lines.
But I just can't understand why people think that they will be able to describe complete software systems of all kinds in pictures (although it's quite possible for some domains and to a certain level).
When thinking of the written word and picture I just can't avoid to think about cave drawings and "real" writing.
It‘s very common to judge the development of a civilization by it‘s capabilities to write. Or as Wikipedia puts it:
„Historians draw a distinction between prehistory and history, with history defined by the advent of writing. The cave paintings and petroglyphs of prehistoric peoples can be considered precursors of writing, but are not considered writing because they did not represent language directly.“
So where does it put our so called "industry" when some of us attemp to describe complex systems in pictures alone?

Saturday, June 02, 2007

Are technical topics no business topics?

I started to write this about a year ago - I think it's time to finish my earlier posts to get at least the basic ideas behind them in writing before I try to start new topics.

Every now and then I come across the silly notion, that technical decisions - like "Java Yes, Ruby No" - are considered to be "not of business relevance" and are to be left to the "IT department" since "the business folks wouldn't know anyway".

Apart from the inherent hubris from "IT" people with that attitude I think this point of view is rather short-sighted. If there are implications the business is not aware of it is the solution providers responsibility to inform the business people.

But - getting back to Java vs. Ruby style questions - to build a certain application with an estimated life-span of 6 month (e.g. because there is a legal requirement for exactly that time-span) might be a sensible thing to do in language 'Y' while it may be more sensible to assign two interns to do manual data corrections than to build an application using language 'X'.

You may substitute X and Y in the above paragraph with Ruby and Java respectivly according to your personal bias (or - for that matter - with any pair of programming languages) but the business people really should have a the last word in the decision.

ceterum censeo: We (including me) should really stop using the term "IT" ... if only I knew a suitable substitute ...

Friday, June 01, 2007

Dictatorship of the Dominant Decomposition

Well I thought this was well known, but obviously it isn't - a least outside the aspect-oriented crowd. So here are a few pointers for starters.

As a matter of fact I was wrong about the phrase though - it is called:
The tyranny of the dominant decomposition
(scroll down a little in the Glossary)

The original Papers can be found at ibm's reasearch site. Opposed to the AOSD glossary my preferred paper is the one about Multi-Dimensional Separation of Concerns. The one about Morphogenic Software is still worth a read though.

Wednesday, March 14, 2007

You want better estimates? Give us more dice.

I'm not sure whether the title works in English, but regarding the way projects are installed in some companies I started to attain the aforementioned attitude.


This is especially helpfull in situations when you're asked "We're not yet exactly sure what we want - but how much will it cost?"

In German: "Ihr wollt bessere Schätzungen? Gebt uns mehr Würfel!"


Powered by Qumana

Monday, December 18, 2006

The 'T' in 'IT' is the worst thing ...

...that happened to 'IT' in the last decade.


Once upon a time...
the craft of software development was performed under the umbrella of data processing and those performing the tasks had titles like programmer, designer, analyst or something along that line. Some of them even came from "computer sciences" or "informatics" but: all of them acted on data or information.


Nowadays - I'd say since the late nineties of the last century - there seems to be a clear line between "business" on one side and "IT" on the other. That wouldn't need to be too bad, but since the "T" in "IT" stand for "Technology" it is.


The "Technology*" metaphor affects both sides. Developers, projects managers and even (software) analysts and designers just take the input - be it concepts or orders or functional descriptions - and try to implement it (or design the system) as good as they can. Business analysts - or who ever describes the content of the project - concentrate on their part of the story and ignore any technical implications.


Sounds fine - doesn't it?


Unfortunately it does! But this seemingly sound separation of concerns is in fact one of the main reasons for time-and-budget overruns, immense time to market durations and similar problems (aka "the new software crisis").


Lets have a slightly closer look at the problems arising from that separation.


Technology & method savvy people get confined to the "techno-space"


Putting all those people with systems design education and experience on the technological side of the imaginary "IT fence" leaves no-one with up-to-date knowledge on the business side of that "IT fence". Of course some business analyst are happily nudging away on the business side of the fence, but they are clearly in the minority.


Most businesses are un-precise by definition - so that is what the business people need to be


To be successful in business a certain degree of leeway is absolutely necessary - people (and most customers are people, even if some of them - namely some of those from the centralised purchasing departments - try to hide the fact) are extremely informal in their perception of the world and in order to generate business you'd better be flexible too.


Business problems don't have to be hard to be expensive - it's sufficient if they are based on "common knowledge"


In the early time of software development software simply was the only way to solve very complex but well defined problems. Finding the correct trajectory to shoot three people from florida to the moon would be one of those well defined but complex problems. Later on there came other types of problem: seemingly simple problems with ambiguos definitions - lets say tax collection. Although theses are 'not exactly rocket science' and you easily get along with the four basic calculation types there are volumes and volumes of law textbooks and interpretations even for one type of tax.


The problem gets worse when people try to describe - or even define - a process 'unambiguously' without proper knowledge. Just try to describe the behaviour of a lift without diagrams. Now add time-awareness and route optimization. And add a second lift, coupled with the first one.


Formal methods should be applied much earlier


Now if you thought of all those fancy diagrams from one of your favourite methods to describe the problem above your probably living rather close to the "T-fence". I personally cross the border very often - either from one assignment to the other or during one single assignment - and every time I introduce some little formal method to business people I am overwhelmed how fast and efficient these methods are applied. It's not that these business people are dumb or ignorant - the problem is just that they don't have a focus on formal methods and are often actively separated from them by the IT-departments.


Agile processes try to circumvent this problem but fail to consider typical german mindsets


It's not only that business and IT use different (formal) languages but also the distance a piece of information has to cover to get from people thinking "business" to people thinking "systems" and back. So the poor guy trying to implement something has not only got to figure out how to implement it but also "what did he/she think that he/she thought what he/she was thinking - and what the heck could be the business reason behind all of these interpretations?". These assumptions - made by the last poor guy in the line - are what eventually make the systems work.


In my opinion the agile processes are a very good way to bridge the distance from business thinkers to systems thinkers (e.g. by placing them very close together) but they unfortunately fail to take local (in this case German) mindsets and organisational patterns into account.


To effectively overcome this situation the "fixed price addiction" (as one of the more direct agile protagonists once put it) has to be overcome - but I'm afraid that will still take a while. In the meantime it could help offer more support to business people earlier.


"bring together, what belongs together"


On the other hand it might be a good idea to allow for more business awareness in the IT-Departments to become more of "systems thinking departments". Although most of the systems work in the end they could get there much faster if the implementing departments would be willing to think more business oriented.


Although this will probably not happen any time soon (at least in Germany) this is one of the occasions where a small step backwards might turn out to be a giant leap forward. So perhaps it's not only about insourcing ousourced IT-departments but about integration of IS knowledge.


Stop using the term IT, make it IS (Information Systems) or something even more appropriate.


Any suggestions?


* BTW: It is even worse with the german word "Technik" because that is often interpreted as "mechanics".


Powered by Qumana


Thursday, October 19, 2006

Reuse considered harmfull?

Although sometimes treated like the "holy grail of the software industry" reuse has never appealed to me as a primary goal.
After I discussed this topic with Olli (sorry: no blog, no personal homepage => no link) last week he dug up the diploma theses from Rupert Stützle (in German) called "Wiederverwendung ohne Mythos" (roughly: "Reuse without myth") which puts a little foundation behind my gut feeling.


I've personally always considered reuse to be an indicator of good architecture and design but the real goal for me is to to have flexible systems where the change impact is as localised as possible. I'll have to take a look at the theses to see if that point of view is also backed up by hard facts.


Powered by Qumana


Thursday, August 31, 2006

O/R-Mapping: A loose-loose situation?

Today (while researching SOAP-Bindings...) I stumbled across a great (and comparatively recent) article from Ted Neward  where he compares O/R-Mapping with the vietnam war. Although this seems a little unpopular to some I'll have to go deeper into the article as time permits. From a first glance I have to say that I couldn't agree more (at least on the technical side)


Powered by Qumana


Sunday, August 27, 2006

Cynical Reengineering ?!?!

I'm not shure really about it right now, but Daniel pointed me to an article about "Cynical Reengineering" wich really appealed to me from the title alone. I'll have to go deeper into this as soon as I find the time.


Powered by Qumana