Agile Relationships

The XP Coach label often gets thrown in with some other descriptive titles like facilitator, mentor, team lead, trainer in order to paint a picture about what the role entails. A big picture indeed, but not all coaches can/will fit all attributed descriptions since each is quite different, particularly mentor.

A mentorship … is a dynamic shared relationship in which values, attitudes, passions, and traditions are passed from one person to another and internalized. Its purpose is to transform lives (Berger, 1990).

If we combine the above definition and this list of attributes of a good mentor [inspired by Lewin, 1993 and Gordon, 2002]; a mentor is:
enthusiastic about the mentee’s progress
willing to help mentee whenever needed
willing to recede when credit needs to be distributed
willing to protect the reputation of the mentee through, for example, co-authorship
leading the way through support and encouragement [not through dictation]
unconditional in accepting the mentee along with his/her’s ideas

… it stands to reason that most relationships within programming, and in particular the emerging programming culture [accelerated through Agile practices like pair-programming] have an element of mentorship: coach or not. Like it or not ๐Ÿ™‚

I have benefitted more from mentors in my career than i have from learning resources. Make no mistake, these resources are invaluable but my mentors shaped my values, challenged my thinking and encouraged my passions. These determine the who i am and not just the what i can[can’t] do.

Mostly though, my menteeship has been ad-hoc [as is most mentoring, i’m assuming]. I wish it had been more explicit since the value it offers is obvious. Be that as it may for me, i do believe that in the now and in the generations to come, mentorship in software should be more explicit.

We all learn tricks from the gurus. This will never change. But where do we learn to think and how do we sharpen that axe, constructively? OpenSource/ forums/ blogs; this is part of it, but relationship is key. Afterall, computers should be about people, right? And mentorship hold some answers. Something we can all take on more explicitly as we advance, always being mentored, forever being a mentee.

Berger, S (1990). Mentor Relationships and Gifted Learners. [] In Boston, B. (1979). The mentor and the education of the gifted and talented. In J. H. Orloff (Ed.), BEYOND AWARENESS: PROVIDING FOR THE GIFTED CHILD
Gordon, J. (2002). Qualities of an Inspiring Relationship []
Lewin, R. (1993). Complexity: Life at the Edge of Choas

Continuing Education Gaps: Part Deux

This is a bit of a carry over from a previous post where i discussed gaps in continuing education. Although the focus of that discussion was about form and function, Raph Koster’s book on game design [A Theory Of Fun] made me realise something else about continuing education: it’s just boring.

A large part of it at least. There’s no shortage of content and no shortage media and presentation variety. But it’s still mostly boring and hence, difficult to engage with. From the learner’s perspective that is.

As a continual learner, most of my time is spent is spent gathering information from blogs, stories and special cases. I will use MSDN, and the like, for a point of reference on technical detail, but if really want to “learn” something- to grok it- i read a story about it.

I read about the human being behind the problem: how and when they discovered the challenge. What did they try, what *almost* worked and why not. What frustrations did they experience and finally, what solution do they suggest. In the story, i pick up on the mood and get to feel with the writer and become part of the adventure. In doing so, i am having fun because i’m engaging in all sorts of patterns thread into the story [implicit and explicit]. I also get to use my imagination: what does the writer look like? what kind of cubicle do they work in? what kind of boss is breathing down their neck? what time of day is it? what is the look on their face when they make their discovery? how do they feel about it? And i know that this is real.

It’s not another hypothetical Bob and Alice story but a real life event. Real blood and sweat and tears are involved in finding the solution and so, in turn i integrate more than one sense into the story. It’s interesting and above all, it’s fun and that’s how i learn.

Then i stare blankly at the table of contents in front of me for a .NET Fusion course. As much as i would love to learn all about it, where do i start? How do i apply all this to my real life; the here and now? As good as it might be for a reference, it’s definitely not something i can learn from…

Design Rules

li#font {font-color: #000000}

Obscurely labelled as the The Zen of Python (by Tim Peters) offers some lighthearted pragmatism and welcome relief in the face of TheCheeseMovement.

  • Beautiful is better than ugly
  • Explicit is better than implicit
  • Simple is better than complex
  • Complex is better than complicated
  • Flat is better than nested
  • Sparse is better than dense
  • Readability counts
  • Special cases aren’t special enough to break the rules
  • Although practicality beats purity
  • Errors should never pass silently
  • Unless explicitly silenced
  • In the face of ambiguity, refuse the temptation to guess
  • There should be one– and preferably only one –obvious way to do it
  • Although that way may not be obvious at first unless you’re Dutch [personally don’t get the Dutch connection but it does apply to some i have in mind ๐Ÿ™‚ ]
  • Now is better than never
  • Although never is often better than *right* now
  • If the implementation is hard to explain, it’s a bad idea
  • If the implementation is easy to explain, it may be a good idea
  • Namespaces are one honking great idea — let’s do more of those[erm… well.. mmm…]

Code Publishing

Being a subscriber [either by email or RSS] to various sites, i get a plethora of handy hints each morning which i archive, either physically or mentally- depending on the juiciness of the hint. Over time, i have noticed that the number of code samples being published daily is increasing. Some are new, some not. Others; interesting twists on old concepts and every once in a while, a real gem. Regardless of their subjective quality, it is encouraging to see the larger developer community thriving and eager to share. Yet, not without it’s a funny little twist.

It’s easy enough to code and it’s also getting harder ๐Ÿ™‚ Gotta love paradoxes. In getting easier to code, it’s getting easier to do the cool stuff that used to take “rocket-scientists” many lines of code and various libraries to get right. It was fragile work and the versions between languages, compilers, linked libraries and even OS’es sometimes, had to be just right. Not so much anymore though. But gettting the fragile stuff right taught you things you didn’t know you needed to know. And on the plus, your application failed fairly quickly [yes, that’s a plus], keeping that feedback loop tight. Now, that feedback tends towards the false-positive.

Applications take longer to fail because the semi-automatic cleanup of resources and layers of abstraction [framework of a framework of a framework] do their best to hide the fragile stuff away. They’re not perfect [yet] but we do rely on them to the point that we can end up writing code with “unknown” consequences [to ourselves that is]. Particularly when we do something outside the majority solution scope. More than it being a problem for us, in our enthusiasm, word is spread too quickly and it becomes a problem for someone else too. Hence an equally growing number of “You did what?!” and support forums ๐Ÿ™‚

And this is where it also gets harder because the framework of the framework of the framework is so overloaded to accommodate every conceivable situation that the volume of required interacting objects increases. And it’s knowing the nuances of each object which is not always easy to do, particularly if you’re not working with it every day. So when your brain hits upon an ingenious little trick, how sure can you be about the assumptions the frameworks below you made about your neat little implementation?

Nonetheless, the ecosystem of sharing we have created thus far is well balanced with a lot of diligent watchers out there making good catches and as enthusiastically sharing the gotchas. It’s keeping that balance in harmony which is interesting as the increasing number of developers communicate their increasing learnings in an increasing technology set within the increasing scope of business possibilities. All this, within the increasing number of mediums in which to communicate…

Of course, the disclaimers about the code not guaranteed to be working in a production environment, yadah yadah yadah, are all good and fine… but you do need to take responsibility for what you publish ๐Ÿ™‚


An Assumption Makesรขโ‚ฌยฆ

Assumptions are wonderful. They allow you to fly ahead without needing to fuss over any time-consuming details… until, at least, the assumption fails you. Like the “ref” keyword, for example.

A data type is a value type if it holds the data within its own memory allocation [Eg. numeric types, bool, any struct types]. A reference type contains a pointer to another memory location that holds the data [Eg. String, any class types].

So, when it comes to argument passing in .Net, by default, all value types are passed by, well, value ๐Ÿ™‚ and reference types too are also passed by value. But value in the case of the reference type, is the value of the reference. This little nuance [nuisance, at first] popped up quite late in my project simply because the implemented design didn’t call for any dynamic re-allocating, until one particular test started failing during what was supposed to be routine “refactoring”. I say “supposed to be” because the refactor ended up changing the behaviour hence no longer a refactor… anyhoooo…

My assumption [reference types = raw pointer, ala C++] allowed me to gloss over an entire section of the C# specification. Had i paid any real thought to this little abstraction way back then, i would probably still have forgotten about it when i had to call upon that knowledge for the first time, months later. Or not. At least now i know i won’t *ever* forget about it ๐Ÿ™‚

Any which way, i still think assumptions are good. Even better though if you can change them. And best if you can constantly challenge them or have them challenged. And yes, an assumption can lead you off into the wrong direction, but hey! At least it’s a direction. Could have indulged the specification in depth before hand and told my employer to wait n months while i read all about C#… don’t think that would have worked too well either.

As always, some tempering between the extremes is a refreshing welcome…

Not Responsible

Experience with service providers over the years has taught me one thing and that is that they all share the same common philosophy:
“We are not responsible for the service we provide you”

Telkom, the South African telecommunications monopoly has this in their terms and conditions, amidst a bunch of other CYA [cover your ass]:
“Telkom may provide hyperlinks to websites not controlled by Telkom (“target sites”) and such hyperlinks do not imply any endorsement, agreement on or support of the content, products and/or services of such target sites”

So, more than just not being responsible for the service they provide you, it seems they are not even responsible for their own website ๐Ÿ˜ฎ How many other companies out there do the same? And then we perplex at the breakdown in the fabric of society. It comes as no surprise really when the public examples are so insipid… aaah, but that itself is another discussion.

Vodacom too has it’s fair share of CYA. I’ve had *issues* with the software they provided [there is no alternative] for monitoring data usage. On more than one occassion i’ve been short-changed 80MB-100MB. Their customer care [less] response: The software we provide you cannot be used to reliably track data usage. Again. Another weak and, quite frankly, pathetic excuse- in the sense that is “so miserable as to be ridiculous”.

ADT, a security provider also suffers the symptoms of this modern day lukewarm customer [dis]-orientated behaviour. After waiting outside our house, in the rain, at night, for 45 minutes for their patrol vehicle to respond- we demanded an explanation. That was weeks ago. Still no word after many phone calls. Again, it seems that they are not responsible for the service they provide.

Edgars, yet another clueless organisation, allowed my mom to purchase a gift card for me which had no credit on it ๐Ÿ™‚ Again, that was my problem. What i have had to go through to NOT have this problem resolved, is unreal. The rest of the list is thick with these weak-willed corporations who make it your problem once you’ve signed a deal with them. And read the fine print. You will see that any problem that does arise: eventually becomes yours. Afterall, you made the decision to deal with them, so deal with it ๐Ÿ™‚

‘Cos remember:
“We are not responsible for the service we provide you”

Disclaimer: the author of this blog cannot be held responsible for any thoughts, messages and opinions expressed herein… yeah, riiiight! puhlease ๐Ÿ™‚ imagine that? what would be the point of saying anything if you weren’t held responsible for it?

Software Updates

It’s perhaps appropriate that i should update my blog with a post on Software Updates. Been quite busy with some exciting delivery my side along with getting a new machine mid-iteration, which is a decent distraction: T60 2.4 Duo. VERY Nice machine and overall impressed with, well, just about everything- particularly ThinkVantage. But in getting my machine production-ready, the sheer volume of updates that i had to do was *staggering* [slightly exaggerated] which got me thinking about my Gran…

Approaching 80, she’s actually about 60. She emails and uploads photos from her digi cam and keeps track of her budget using Excel. Not bad for a soon-to-be octogenarian. But how often does she update her PC?

First, there’s the OS updates- in this case: Windows Update. Then there’s the driver updates for anything particular on your machine. Then there’s manufacturer-specific system management updates and that’s before you get to your “third-party” application software updates like anti-virus, for example. And these are not small updates either.

Windows Updates: about 21 in total [many MB] and the machine came preloaded XPSP2.
Driver updates: ATI as an example: 47MB! Thats’ not including updated drivers for fingerprint readers, wireless drivers and yadah yadah.
System Management Software Updates: Yes, ThinkVantage itself needs to be updated before you can use it to check for updates ๐Ÿ™‚
AntiVirus updates: using AVG and that totalled about 15MB from my current installation. Could have used preloaded Symantec but the updates are just as heavy.

Granted, not all these updates are critical- but how grokkable is determining severity levels based on the information presented:

“No, ma’am the ATI update is not critical, but we do recommend it” – or-
“that update for XP 64-bit is optional, so don’t worry about it.” Which means what [to my Gran]?

With all these updates needing to take place, and getting back to my Gran… What happens if i DON’T run these updates regularly? And another thing: WHY are there so many updates?

Is the software just poor quality?
Are all these companies finally adopting Agile and releasing incremental “enhancements” as opposed to fixes? ๐Ÿ™‚
IS QA just getting better at what they do and finding more and more problems?
Are systems become so complex that inter-operability and coding for it is laying a foundation for latent problems?
Is software been pushed out the door because the market has become so aggressive that an incremental release strategy helps keep the company competitive?
All of the above?

Too many questions for a Saturday morning, but i wonder just how many new PC/laptop owners install updates knowingly? And if they don’t know they’re actually updating [preconfigured under the guise of “user-friendliness”] if they notice their bandwidth getting hogged every so often?

…there’s a surgeon doing a remote heart transplant operation and s/he accidently removes the kidney as well because the system software was not configured to update automatically… ๐Ÿ™‚

I think we still got quite a way to go before we can comfortably integrate technology easily into our lives…