Monday, March 26, 2018

R.I.P Mike Beedle


Saturday afternoon, I learned from the Enterprise Scrum community that Mike Beedle died in Northwestern Memorial hospital, the victim of a fatal stabbing in Chicago:
"It is with a heavy heart that we bid farewell to Mike Beedle – business agility visionary, agile manifesto signatory, founder of Enterprise Scrum and friend. Several hours ago, the Enterprise Scrum community confirmed that Mike was fatally injured in a stabbing in Chicago. Our thoughts are with his wife, children, family and friends. In this difficult time, the community has come together and created a gofundme project to raise funds for his family. -R.I.P. Mike Beedle, Business Agility Institute.  [See news clips from ABC7Chicago, NBC Chicago, Chicago Tribune]
A few day's later, I still haven't fully processed this. Mike was more than just a colleague, co-thought-leader, and former co-worker to me, he was an old and dear friend.

I first met Mike in 1995 via OTUG (Object-Technology User's Group) that formed as part of "Booch & Rumbaugh on Tour" (which eventually resulted in UML). We were both part of the OTUG mailing-list (as were many other notables in the O-O community, like [Uncle] Bob Martin) and learned that we literally were working across the street from each other (Mike was still working for Mercer at the time). Mike invited me to meet for lunch nearby, to discuss our mutual interests in OOD and Design Patterns, and we quickly became fast friends and colleagues.

From 1995 thru most of 2004, we corresponded and/or spoke almost daily, and had lunch together at least once a month. We bounced ideas off of each other, reviewed each other's works-in-progress (books & papers), and regularly discussed what we were passionate about in the field. We were also highly-active contributors in all the major online forums about Design Patterns (and later, Agile development) but also on the very first ever WikiWeb (Ward Cunningham's Wiki Web), where Mike started off my first WikiPage for me. 

In 1997 (~1 year after Mike left Mercer and started his own consultancy, Framework Technologies), still enthusiastic about patterns, and especially patterns of organization & process design, Mike and I  founded The Chicago Patterns Group (TCPG), along with Jim Coplien, Bob Martin, Ralph Johnson, Ron Crocker, and Bob Hanmer. We met monthly at the Border's bookstore in Schaumburg (1540 Golf Road, across from Woodfield mall). A year or two later, James Grenning joined us (another Agile manifesto co-author). 


Border's bookstore in Schaumburg, where TCPG met in 1997-2001

Between 1997-2000, aside from co-leading TCPG, Mike had a semi-recurring consulting 'gig' at Motorola in Arlington Heights, where we got to interact even more frequently after I moved there from Motorola's Northbrook campus (in May of '98). We also got to chat more frequently with Ron Crocker then too (my workspace was practically right next to Ron's for much of 2000-2004). I mention this because Ron Crocker created what may have been the very first "scaled" Agile method (Grizzly, eXtreme Programming at scale) during that time.

Mike & I traveled together to several of the PLoP Conferences (Pattern Languages of Programs), and were program/review members and writer's "shepherds" for several years. We were even roommates at PLoP'97, PLoP'98 & PLoP'99. [In fact, much of the way to PLoP'97 was a horrible rainstorm! I couldn't see more than 20 feet in front of me, and had to follow Mike's tail-lights for several miles until we eventually pulled over to the side of highway and waited for the storm to taper off]

The pictures below are from PLoP'97, where Mike and I were in the "People and Process" workshop group (along with my SCM Patterns + Agile SCM co-author, Steve Berczuk).


PLoP'97 - People and Process Workshop Group

PLoP'98 was where Mike herded together Scrum creators Jeff Sutherland & Ken Schwwaber, along with Martine Devos and Yonat Sharon to create the first written description of Scrum's practices in "Scrum: A Pattern Language for Hyperproductive Software Development [It's also where Steve B. and I co-authored the first installment of our "Agile SCM" patterns for Branching and Merging, including the variant of Mainline (LAG-Mainline) that is  more commonly called Trunk-based Development today]. 



PLoP'97 - People and Process Workshop Group, Monticello, IL

On a more personal note, Mike and I carpooled together for PLoP'98: We met for brunch at a nearby Bennigan's, and met each other's spouses (Mike's 1st wife Laura) where Mike announced they were expecting their first child. A few year's later my wife and I were expecting our first, and met up with them for lunch again. We met for lunch at the same place again two years later, with our respective kids, all toddlers and/or infants (I still can't believe we made it thru lunch without either of our kids breaking anything while we were there).

In Jan of 2001, Bob Martin was arranging the famous get together at Snowbird Lodge (where the Agile Manifesto was created). I remember Mike telling me about it, and emailing me to tag-along and go with him to the event. I already more than had an inkling of just how momentous the event would be, and really wanted to go (even considered paying my own way when my then employer wouldn't, but knew they would give me grief if my name appeared on the result). 
Creators/Authors of the Agile Manifesto - Feb 2001, Snowbird Lodge, Utah


They decided on the term "Agile" to characterize the set of methods, but it was Mike that first suggested the term for software development during that retreat. I know this because it was during 96-97 that I recall Mike first using the term "Agile" and "Business Agility" to describe the desired outcomes of applying the kinds of organization & process patterns that he and Cope and others of us were writing about. And I asked Mike specifically about it afterward, to confirm.

As soon as Mike got back from Snowbird Lodge, we founded the Chicago Agile Developer's meetup-group  (ChAD) along with Bob Martin, James Grenning, Martin Fowler, and Lowell Lindstrom.  It was so named, in part because of the 2000 U.S. presidential election (the "hanging chads"). ChAD was probably the very first "Agile meetup" in the U.S. (possibly even the world). Our first meeting was April 25, 2001 at Object Mentor in Vernon Hills. (And the first book on Scrum, co-authored by Mike, came out during that time as well). 



Mike and I planned and arranged ChAD meeting agendas & events (we met monthly, both downtown and in the NW suburbs), right up until our Sep 11 2001 meeting, which was to be in the Sear's Tower. The meeting ended-up being cancelled of course (due to 9/11 happening earlier that day) and the group went on hiatus for ~6months afterward, then revived itself with the help of Wyatt Sutherland. Mike, Wyatt and I would meetup for lunch every couple months or so to catch-up and plan future events & outings.

Mike and I remained big fans/supporters of each others work (but also honest critics). Our respective careers were each going their own direction, and after 2004/2005 we sort of drifted out of touch for awhile, but kept up occasionally (on the various Agile lists/forums, and also on Facebook). 

Then in late 2016 we reconnected, and within a year Mike was kicking off his latest Enterprise Scrum endeavor. Including the facebook group, and his articles on medium.com. Mike even credited myself and 15+ others with his definition of "Business Agility" for Enterprise Scrum (that's the kind of inclusive and collaborative leader he was). 



He started the Enterprise Scrum for Business Agility meetup and training sessions in downtown Chicago, and I got to see & speak with him on a regular monthly basis at his downtown meetup. 


Enterprise Scrum Business Agility Conference, October 2017, Chicago, IL

Most recently, in January of 2018, Mike and I attended Michael Sahota's CAL I training together, where we really had a chance to catch-up and reconnect in depth again (which I was so grateful for at the time, and now even more so).


CAL-1 Leadership Training with Michael Sahota - 26 Jan 2018, Chicago, IL 

Not only was Mike impressively smart, but impressively talented too:
  • He held a Ph.D in high-energy physics, 
  • He played piano and guitar like a pro (we used to jam together at PLoP)
  • was well read in literature, poetry and philosophy (not just patterns).
  • Also, Mike had one of the first working software packages for HIPPA (using XBreed [Scrum+XP]). 
Mike Beedle was brilliant, visionary, a genuine "renaissance man," and true world-changer with his contributions to Patterns, Scrum, the Agile Manifesto, and was poised to do the same with Enterprise Scrum for Business Agility. He was as generous as they get when it comes to support, openness, thought-leadership and encouragement. 


Mike Beedle @ Enterprise Scrum, Business Agility NY, March 2018

Above all else, Mike was PASSIONATE about the things and people he believed in, and determined to change the world and make it (and us) better for it [which is exactly what he did!] I hope we are worthy of carrying-on his work with Enterprise Scrum to see it thru to fruition. 



Miguel, mi amigo, Vaya con dios! (You have more than earned it!!!)

Those who wish to help Mike's family (and six kids) in Mike's absence, please visit gofundme.com/mikebeedlesupport 

Thursday, August 20, 2009

SOA, Mashups, Mashed Knees and Surgery

Today is my birthday - I had arthroscopic knee surgery last night and am feeling pretty good so far (happy birthday to me). I know I still have a lot of meds/painkillers in my system and that its going to feel more uncomfortable the next few days. I'm still hobbling around on crutches but I'm feeling much more confident that I can attend (and present at) Agile2009.

I received some very good books on Mashups and SOA a few months back and I'm finally getting a chance to look at them in some more detail. They really are quite good! I think Mashups are the "latest frontier" for realizing the promise of SOA, and a natural evolution from Wiki-webs. Here are the books:

If you follow the links above to the InformIT.com homepage for each of the above books, you'll find some good excerpts and related articles that will give a preview of what to expect so you can judge for yourself.

Thursday, August 13, 2009

BOOK: Running an Agile Project

First, on a personal note, I had the misfortune to tear cartilage in my right knee a couple days ago and will require surgery to repair/remove it. I'm hobbling around on crutches for the time being. I hope I can still attend (and present at) Agile2009.

Anyway, my review of Mike Holcombe's book Running an Agile Software Development Project appears in this month's Agile Journal.

Running an Agile Software Development Project is an interesting book. On the surface it looks like it would be very academic, because the author, Mike Holcombe, was a University Professor at the time, and running an “agile software development factory” of students (albeit for a real commercial development shop). And yet what is described in the contents is very much the practical, real-world results of running agile projects with those same people for real IT software development work.

[...]

Overall, I found Running an Agile Software Development Project to be interesting and enjoyable. It still seems just a bit academic for my taste, and probably wouldn’t be the first book I would recommend on the subject unless it was for a classroom audience (in which case this book would be an excellent one to use).

You can read the full review here!

Friday, August 07, 2009

WANTED: Seeking Single Agile Knowledge Development Tool-set


I'll be presenting at Agile2009 in Chicago on the Tools for Agility stage on Tuesday 25 August, 4:45pm-5:30pm.


Here is my session description from http://agile2009.org/node/2762

WANTED: Seeking Single Agile Knowledge Development Tool-set


Aren’t code, backlog-items, tests, designs & documents all just different forms of system knowledge at different levels of detail? Why can’t the same tools help refactor, browse, search, and provide build/test automation for non-code forms of knowledge without requiring a separate tool/repository for each format? This talk is intended as a challenge to tool vendors/developers to see how this simple treatment of all non-code items as part of a single, unified project knowledge-base can be at once both immensely powerful, and imminently practical, without requiring too much added complexity.
Process/Mechanics
Approximately ~30 minutes of slides/presentation to “make the case” for why this approach is useful and desirable, followed by discussion of challenges (to and from tool developers/vendors, as well as the rest of the audience) as to its usefulness and benefits, and why their current tools can’t easily do so and why the should or should not be easy to enhancement them to do it.

Outline

Software development as knowledge development

  • Source-Code as knowledge
  • Requirements (Stories) and Tests as knowledge
  • Other usable forms of project knowledge (e.g., build scripts & configuration, build/test result reports version control history/comments, online help & other supporting docs)

How would I do this?

  • Refactoring Knowledge (thinking about the rest of the “knowledge” the way we think about the code, and its habitability, navigability, and structure/refactoring)
  • Applying other agile-practices (like TDD, Continuous Integration, etc.) to non-code knowledge development
  • Wiki-based skins, DSLs, and use-cases/design as domain-driven Wiki-word definitions
    • Patterns (giving things names), Retrospectives results and lessons learned
  • Viewing, searching EVERYTHING (even the code) via wiki?
  • The “Wu-Wei” of Traceability (Tracing without Tracing)
  • Versioning and operating on wiki-like entities, just like with code (e.g., making “working copies”, branches and tags)

DISCUSSION & CHALLENGE: Why can’t (or how can) YOUR tools do this!

Begin audience discussion/dialogue: Why can’t a tool like Eclipse or a Wiki-based CMS (such as Confluence) be used as a front-end to browsing/refactoring and navigating ALL the knowledge of the system? (not just code, but stories, tests, build/config data, CI reports, backlog, retrospective lessons).
What makes it easy/hard for these and other tools like any of the following to do this, or to be simple “skins” or plug-ins on top of only a handful of tools instead of a whole kitchen sink full of separate tools and repositories.
  • Eclipse, Confluence, Twiki?
  • FIT, Fitnesse, Contour
  • Doxygen / Javadoc
  • Trac / Agile-Trac?
  • Jira / Remedy
See also a blog-entry of mine entitled Can I have just one repository please?
Learning outcomes
  • Thinking about Agile development as knowledge management & creation
  • Current barriers to using agile techniques and supporting tools for non-code artifacts
  • What do refactoring, TDD, continuous integration, etc. mean for non-code artifacts (and why you should care)
  • Use of wikis for organizing, structuring and refactoring ALL system knowledge
  • Why manual traceability is unnecessary (and even comes for free) when using such an approach

Primary target persona
  • Tomas Tool-smith/Tool-vendor

(download PDF here)

Saturday, August 01, 2009

Studies on Effectiveness of TDD?

This question came-up in a discussion earlier this week: Do we know of published studies on this subject? A quick Google-search turned up the following for me ...


Any others? Any comments on the above?

Sunday, July 26, 2009

Resources on Retrospectives

I found a really good resource-list from George Dinwiddie on Introspection and Retrospectives that includes the following list of resources (mostly patterns & techniques) about conducting retrospectives. It contains many (but not all) of the links below:



Friday, July 17, 2009

Refactoring @ Scale

In my previous post, Refactoring for Agility, I posted an outline and some thoughts for Part I of an Overview on Refactoring. Now I'm ready to post on Part II which is about refactoring @ scale. By "at scale" I mean in the larger context of other agile practices, as well as for large projects.

PART II - REFACTORING @ SCALE

1. Scaling-Up
  • To scale refactoring for larger projects, some additional techniques & issues must be added to the mix.
  • Note that this is “in addition to” (not “instead of”)
    Refactoring In-the-SmallRefactoring @ Scale
    Small, Fast & Frequent RefactoringsLarger, Periodic & Planned Restructurings
    Emergent DesignIncremental Design & Evolutionary Architecture
    Deferred RefactoringRestructuring & Technical Debt
    Code SmellsArchitecture Smells
    Design Principles & PatternsSoftware Modifiability Tactics
    Simple/Clean CodeSupple/Domain-Driven Design

2. Emergent Design
  • Emergent Design is a fancy name for the resulting design that “emerges” from the synergy of combining Refactoring together with TDD, Continuous Integration and Automated Testing.
  • Emergent Design means that ...
3. Technical Debt [a.k.a. Design Debt]
4. Restructuring Technical Debt
  • If we accrue a non-trivial amount of technical debt, we can’t simply “refactor” it away.
  • Paying it off typically requires restructuring efforts (or even reengineering) that must be planned.
  • Iteration plans must accommodate specific tasks for these restructuring efforts (or even be dedicated to restructuring).
  • Ignoring it, or deferring it for very long is not a viable option!
5. Overview of Restructuring
  • Identifies higher-level issues (“architecture smells”) that typically represent violations of known principles of good software architecture & design.
  • Periodically applies larger-scale “refactorings” and/or many small refactorings that were previously deferred.
  • The goal is to “pay down technical debt” in order to limit the increasing costs of accumulated complexity.
  • Typically requires a concerted effort that must be separately planned.
  • Uses not only design patterns/principles, but also architectural patterns/principles, as well as software modifiability tactics.
6. Refactoring vs. Restructuring
7. Restructure Periodically
  • Restructuring is often associated with absent or neglectful refactoring and/or design.
  • But … Any large software project spanning multiple teams eventually needs restructuring.
    • Even in the presence expert-level architecture, design & continuous refactoring
    • This is just a reality of software evolution/entropy
  • Therefore … Large software projects should assume that periodic restructuring will be necessary, and should plan accordingly to:
    • Clean-up accumulated code-smells and apply numerous refactorings that were deferred but are now sorely needed,
    • Address architecture smells by applying restructurings, patterns and modifiability tactics that have broader impact.
8. Architecture Smells
See Stefan Roock's and Martin Lippert's book Refactoring in Large Software Projects (There was an earlier version of their work entitled Large Refactorings").
  • Smells in Dependency Graphs
  • Smells in Inheritance Hierarchies
  • Smells in Packages
  • Smells in Subsystems
  • Smells in Layers
9. Software Modifiability Tactics
  • Localize Changes (increase cohesion)
  • Prevent Ripple Effects (reduce coupling)
  • Defer Binding-time (defer decision-making)
10. When to Consider/Plan Restructuring?
11. Evolutionary Architecture
  • Software Architecture concerns infrastructure elements that must exist before you can begin execution.
    • Architecture is about things that are hard to change later, it is difficult to allow an architecture to emerge.
    • For large projects, this includes high-level organization of the system into functionality/elements that will be allocated to separate teams.
  • Key techniques of Evolutionary Architecture include:
    • Deferring Irreversible Decisions to the “Last Responsible Moment” (LRM Principle)
    • Architectural “Spike”, Architecture Iteration and/or Spike Iteration
12. Incremental Design
  • Design evolves incrementally, iteration by iteration, based on current business priorities and discovered technical limitations.
  • Incremental Design …
    • Does not prohibit thinking about higher-level design.
    • Does encourage planning in detail only what will be constructed soon.
  • Focus is on “Just Enough, Just-In-Time” :
    • Specifying too much detail too soon causes more rework later.
    • But doing less now and saving the rest for later should not require significantly more work later than it would today.
  • We must do Just Enough Design Initially to attain the right balance of anticipation and adaptation.
13. Just Enough Design Initially (JEDI)
  • Initial design (before coding) is still necessary.
    • This use of “JEDI” was coined by Stephen Palmer as part of Feature-Driven Development (FDD)
  • Basic rule of thumb to tell when “JEDI” is achieved:
    • At iteration-scope, when, after one pass through the iteration backlog, modeling in small groups does not produce any new classes or associations of real significance.
    • At task/TDD scope, when we have defined enough structure & interface(s) to know specifically what code to write/test, precisely where to write it, and exactly how to invoke it.
  • Techniques of “the JEDI way” include:
    • Collaborative Domain Modeling and Color Modeling [from FDD]
    • Supple Design techniques & patterns
    • Domain-Driven Design (a.k.a. DDD -- see domaindrivendesign.org)
    • Design Blitz & other Agile Modeling techniques (see agilemodeling.com)
14. Supple Design & DDD
  • Domain-Driven Design (DDD) approaches modeling the core logic of the software by focusing on the domain.
    • The basic idea is the design should directly reflect the core business domain and domain-logic of the problem to solve
    • This helps understanding the problem as well as the implementation and increases maintainability of the software.
  • DDD uses common principles and patterns as "building blocks" to model & create a "supple design”
    • Supple: pliant, malleable, limber, yielding or changing readily.
    • The design is firm yet flexible, with structure and intent both clearly conveyed and deeply realized by the code.
  • Patterns of Supple Design include: Intention-Revealing Interfaces, Ubiquitous Language, Side-Effect-Free Functions, Assertions, Conceptual Contours, Standalone Classes, Closure of Operations, Declarative Style

15. Resources:

Resources on Emergent Design and Evolutionary Architecture Resources on Restructuring Resources on Technical Debt Resources on Modifiability Tactics Resources on Supple Design & DDD