Back from the Lean Kanban Conference

I'm back and planning on posting to my blog more. I've been posting on Twitter (http://twitter.com/jheintz) fairly regularly now. Some stuff just doesn't fit within 140 characters...

The Lean and Kanban conference was awesome: both humbling and inspiring. My trip report will show up on The Agile Executive blog (http://theagileexecutive.com/) soon... I'll post a direct link.

Below is a summary of my twitter activity, just to get warmed up.

1. @TheOtherAlistai @RonJeffries Iteration is like metronome, Kanban is like multiple rhythms, from #lk2009 (must find who said that...)2:42 PM May 9th from Tweetie
2. RT have a YouTube link for this eating style ;) -- @jeremiahakin: Langston eats apples like mr peepers from Saturday Night Live9:36 PM May 8th from Tweetie
3. #lk2009 So long, Miami, and thanks for all the fish!3:02 PM May 8th from Tweetie
4. @agile_exec Picked up a Lean Kanban Conference preceesings book for Israel... Who really should have been here! #lk20091:10 PM May 8th from Tweetie
5. @alshalloway great conversation about how/why Kanban removes fear/impedemnts to individual learning, must blog! #lk200912:37 PM May 8th from Tweetie
6. @agilemanager why is introducing Kanban easier than Scrum? I'm suggesting Kanban provides concrete reflection tools, lowers barrier #lk20098:36 AM May 8th from Tweetie in reply to agilemanager
7. Err, I meant tuning WIP and workflow is easy for people that wouldn't normally contribute to retrospective #lk20098:26 AM May 8th from Tweetie
8. Tuning WIP limits and workflow on the board is low resistance, even fir people that normally would say a think in a retrospective #lk20098:24 AM May 8th from Tweetie
9. I said concrete introspection is maybe the reason kanban is different. Just telling people to reflect doesn't just work. #lk20098:22 AM May 8th from Tweetie
10. I said concrete introspection, I mean that most people won't retrospect. Getting more people thinking in the biz is the real win. (hypothes)8:21 AM May 8th from Tweetie
11. Laribee just compared Kanban boards to the RESTful web metaphor... #lk20094:40 PM May 7th from Tweetie
12. Any good survey of online kanban tools? #lk200911:20 AM May 7th from Tweetie
13. Any good summary of online kanban tools? #lk20911:03 AM May 7th from Tweetie
14. Alisson Vale contract agreements: problem solving, support, improvements for sustainability, new value #lk200911:02 AM May 7th from Tweetie
15. Alisson Vale defined four (social?) contracts with customers #lk200911:00 AM May 7th from Tweetie
16. Alisson Vale "long term relationships require long term contracts" #lk200910:58 AM May 7th from Tweetie
17. @carlacorkern Chaka what? :) I'm at the learning gemba, not vegetarian.10:42 PM May 6th from Tweetie in reply to carlacorkern
18. @dennisstevens I'm not sure TWI is right either, but I have a strong hunch that is has wisdom for teaching knowledge workers. #lk20094:12 PM May 6th from Tweetie in reply to dennisstevens
19. #lk2009 link to TWI resource: http://delicious.com/jheint... training within industry is a WWII management system that influenced Lean.4:05 PM May 6th from Tweetie

Hotkeys for Omnifocus/Firefox

Until I get a chance to try out this integration for Firefox and Omnifocus (http://forums.omnigroup.com/archive/index.php/t-4510.html) I wanted to make a record of the hot keys I'm using right now.

Goal: Get a link to the current page I'm viewing in Firefox into a new task in Omnifocus.

Steps:

1. Command-L to get the browser location URL highlighted.
2. Command-C to copy that location.
3. Control-Alt-Space to open a new Omnifocus inbox item.
4. Type a short description of the new task.
5. Command-' to open the entry field for the notes. (This is single quote, not back tic.)
   
6. Command-V to paste the previously copied URL.

It works, avoids using the mouse, but that is too many steps.

My best code review

In 1998 (or maybe 1999?) I was a fairly junior developer, but fortunate to be working under a really smart mentor (Aamod Sane).

Among many things that I'm grateful for was his relatively constant practice of helping me through constructive code reviews.

The one that sticks out, the one that changed my view of how to write my own code, started out with me excited with finishing the code and a few tests for some now forgotten task.

After reading through it myself to hopefully avoid really stupid mistakes ;) I kind of ran down the hall to get the attention of my supervisor/mentor.

Once he finished what he was doing we started walking back towards my workstation.

[...this is where it starts to get interesting...]


On the walk back towards my machine I was nervously and rapidly telling him what, why, and how the code does what it's supposed to.

[Me doing all this quick overview talking was important actually...]


We sit down at my machine, swivel the monitor over, and he start reading.

He....
sighs.



Then....
shakes his head.



Really. That's what happened.
Yes, you know what I felt like. ;)


If it had just ended there it would have been like any other awful code review (see http://www.osnews.com/story/19266/WTFs_m)



So, finally, the really good conclusion.

Before he left he said this to me:

Just make the code look like what you just told me.

That walk between machines earlier when I rambled my way through telling him what the code did was actually a fairly clear description of things. The code I had actually written was really detailed, messy, and all together just "code".


After the advice of my mentor, I looked at the code with fresh eyes and I could see better method names, better looping patterns, and just better ways to "tell the story" of what I was trying to do.


Now, I try to write my code so that it "reads" like a good story. Sometimes I do a really good job, and other times not so much, but I have a clear goal that I'm shooting for.

My Favorite Inverview Question

In a recent discussion interview questions came up, here's my favorite one.

To set some context this question is designed to gauge the abstract and critical thinking of a generally inexperienced developer. I don't usually use this for very experienced developers, but may if I think I'm getting shallow or suspicious answers.

Here's what I start with:

I'm friendly but not at all helpful while I do this.

• I draw it out by hand on a whiteboard or on paper
• I verbalize the relationships
• I offer to explain the notation and meaning of "is-a"
• I ask them to think out-loud
• I hand them the writing instrument
  

Then I just ask the candidate for their impressions of the model.

• What's good? What's bad? What would you change?

A few obvious things that the candidate should work their way around to:

1. A "Deer" is an animal also.
2. A "Cow" could be "Food" for a "Tiger".

After watching them squirm for a while, I then make one addition to the original model. I add a single method/operation to the "Animal" class.
Again, I ask them for their impressions.

If they don't get to it themselves I make sure to ask the following questions:

1. What happens if a "Deer" is passed to the eat method of a "Cow"?
2. How would you change the model to handle or avoid that problem?

Enjoy!

Comments, REST, Interactions, and Extensible Hypermedia

This post is to mostly keep track of the numerous blog threads going on about IDLs and schemas for REST. I find myself with more to say that wit to organize it... :(

First my summaries of opinions, then links to my comments here and there.

Some of my opinions on a RESTful Client Engine, and what types of server-side changes would NOT break a client:

• URIs are discovered (except the first)
• Server-provided data extensions (hidden fields with defaults in a form) are treated like "does not understand" but still submitted properly
• Changes to which HTTP verb are used. The server can swap PUT for POST without issue (verb is discovered in form not spec'ed in a schema)
• Changes in state path. "checkout" could directly be a single form with POST, a GET link to a single for with POST, a POST to a form with reliable PUT semantics, .......
  

Links,opinions on the changing landscape of content (and predictions of the future of hypermedia content):

• Sam Ruby's suggestions for HTML5 Distributed Extensibility is a fabulous starting point.
• URI Templates, HTML Forms, XForms, Web Forms, WADL
  
• XSD is being extended to better support versioning
• Data schemas designed for extensibility should allow everything possible to be optional
  
• Microformats enable opportunistic clients to machine process
• GRDDL leaps from microformats, xml, some json up to RDF
• HTML+Microformats can do a ton of this already, but with no machine processable anything
• Prediction: in 10 years all of this this will have exploded/merged into one or a few really cool and evolvable data/interaction schema systems
  

References to programming and type systems that address these issues more appropriately than any IDL (as far as I can get into them so far... :)

• from Stu Charlton comes a reference to interaction machines
• from Todd Hoff comes a reference to two NASA reference on Mision Planning and Closed Loop Execution and Recovery
• papers from Luis Caires, for example Spatial-Behavioral Types, Distributed Services, and Resources
  (forget where I found this material from... can't understand it yet...)
  

The following is a guide to my recent comments on these threads from around the web:

Subbu says:

Should this idea be extended to the rest of non-user facing resource-oriented applications? I don't think so. Here is why.

The idea of hypermedia embedding all the action controls necessary to interact with the server works well for an arbitrary number of universal clients interacting with a given server. In this case, the server offering a set of resources specifies all the ordering/interaction rules within the representation. Most application clients, on the other hand, interact with more than one server, and the ordering constraints can not be set by any given server. The clients know how to compose applications out of resources offered by various servers, and each client needs to be able to exercise control over composition. To be able to exercise such a control, client applications can not be universal, and the benefits that John lists above cannot be completely realized.

My comments is that clients should be opportunistic: if they understand some shared semantic (like a RESTful shopping API or task manager) then they can automate some interactions.

On JJ Dubray's blog I make several comments.

In response to "REST creates strong coupling", I say:

• JJ is ignoring the shared definitions of MIME types
• The globally shared "Provider external" (Pe) semantics in REST are (URI, GET representation, hyperlinks)
• in WS-* the Pe globally is 0 (zero), only particular shared uses have a shared semantic.
  

In response to "REST and inter-actions", I say (and say and say):

• For me REST in the enterprise isn't about scalability, but rather independent evolution and support for partial failure.
• In maybe 10 years there will be an XML schema language that properly supports versioning and extensibility

In Steve Vinoski's blog on "IDLs vs Human Documentation" I comment that:

• I side with Patrick Mueller: there is something of value in more than just prose to document RESTful systems
• Hypermedia MIME types are _more_ than just a data schema (embedded forms to signify actions)
• A list of RESTful interactions that _shouldn't_ break a programmed client (listed below)

Premature Conclusions with Services and REST

Damn, I wish we were at a white board. Oh well.

JJ, you've drawn a lot of conclusions from talking with a few people in the REST community. I think you've gotten ahead of yourself.

To defend the "REST community": What we are talking about isn't where most of the value is. Not yet anyway. Maybe someday this issue will really be an issue, but right now just GETing info with declarative representation data is so unusual that we're on the fringe.

Really, I believe this on the internet at large and in many organizations as well (enterprisey doesn't even get funny when sharing a database is so common.) . How much value does a definition language really have? Well, some. Just like I appreciate static languages for documentation and _some_ checking, having a WSDL or something is useful. None of the things being thrown around for "interface definition language" are much more useful than being able to organize documentation, generate code (a bad idea), and create pictures (sometimes useful for humans). That last point, the human part, is where you started this conversation... Let's not pretend that WSDL allows machines to process things for us.

To your recent post. I don't have much time tonight, but hear is my reaction.

Shared Understanding.
This isn't actually denied by the REST. It's just relegated to the media type.

The "contract" that is specific to a particular domain in a RESTful system is buried in the Representation. That means a) we all collectively don't know much about it, b) every system can use the standard VERBS to explore and partially integrate. The first point means we need to have this very conversation, but the value of that struggle is more common ground between all services.

Result Sets aren't Resources
Huh? Why not? I'll need to read up on the posts, but everything interesting is a resource. I don't understand why you conclude this.

Some of your recent posts have indicated what I think may be a confusion regarding the "uniform interface" and resources. Not every resource must support and expose each method. Part of the discovery of REST is learning (at runtime) what methods are available for each resources. Results sets don't need to expose PUT.

How many people are in this discussion?
Not many, I'm afraid. You're assuming that people won't discuss these issues with you, but it's probably that it doesn't matter to most of the RESTful systems out there.

As an example: the Amazon service exposed this weekend. It is people (not machine processes) that are writing the wrapper layers around the new API. It almost doesn't matter what they had exposed it in, people need to spend thought understanding it and wrapping it. Then, other people, need to consume the wrappers to write applications.

Had Amazon used some magically fantastic definition language it wouldn't change but a part of the total human/computer processing cost and value proposition. Again, I think there is value in understanding and exposing that fantastic definition language. I'm not assuming it will magically compose my systems. (I'm not necessarily claiming you make that declaration either, but the value you place on the formality seems too strong. I will read your book on composition to really understand what you are saying.)

REST and actions
There is something critically important about the distinction between "action interfaces" and "document exchange". You took Subbu to task for trying to remove actions, but I think there is a truly subtle reason that REST motivates that thinking.

I'm not sure I can express it well, but this is my intuitive view:

• contract negotiation is an (endless?) cycle of document exchange
• reserving a _good_ hotel room is an cycle of question/answer...
  
• bartering is a cycle of bid exchange
• resolving a speeding ticket is ...
  

what these real ways of getting things done tell me is that an interface contract doesn't model the real world.

REST models "action" as one or more transfer of document representation. That is more like the world than interface actions.

REST and versioning.
Really bad at versioning? Seriously? If you'd said "efficiency", or "tool support", or "machine clients" I'd be right there saying "Yeah, maybe this would improve that..."

Versioning is hard because something wants to change - and the rest of the system isn't yet ready to change as well. REST has from the beginning been about supporting that change (across organizations, and between the client and server). The very reason that interface definition languages are so hard to reconcile with REST is because of the radically different view on how to support evolution.

(I'm posting this without all the links...)

Shared Understanding and/or Evolvability

(This is belated and too short. All you fast-typing bloggers out there can just be patient :) Sorry for the delay!)

How do distributed systems both cooperate and evolve?

That is a subtly different question than JJ asks:

when no human is in the loop, you need a shared understanding between the resource consumer and the resource (provider)

The only viable choices JJ then describes (WSDL or WADL) do indeed provide a partial solution to coding shared understanding, but not evolution.

The short (flip?) answer to my leading question is to create a new media type that describes the semantics necessary for both consumers and providers to communicate.

In the case of exposing a Job Application Service as a RESTful provider that could mean the following:

• for a human provide an HTML response representation with forms for review, cancel, submit interview.
• for a machine provide an XML or RDF (or something) response representation.

That machine representation must have a lot of things going for it. It must provide just enough shared information to do useful things, but not prevent service evolution. In particular, the response must:

• provide links/conformance to some shared schema type(s) (to share semantics)
• be extensible (in the "does not understand" sense)
• the shared schema can't pre-define URIs
• the shared schema can't pre-constrain all of the transition paths
  

That last one is really fuzzy, but I'm trying to express the idea with my "signposts" metaphor. Getting something done (i.e. changing the state of something) isn't alway a single step, and how many steps have to be followed isn't a very stable property. In the case of job applications, getting from "offered" to "accepted" might take a few loops in the 1.1 release of the service, or maybe the "review" state gets split into 2 steps, what happens then?

The current conception of "shared understanding" is "shared interface". In the Job Application example that means the client service is encoded to expect after "Submit Review" that the service moved the job app to "reviewed". If the client service instead was coded to have a pair of (current job app data, desired state) when the service changed to a 2-stage review process the clients would likely continue to work:

• Client: Get job app 123
• Service: job app 123, submitted, "Submit Review", "Cancel"
  
• Client: "Submit Review" for job app 123
• Service: job app 123, review1, "Submit Review", "Cancel", "Reject"
• Client: "Submit Review" for job app 123
• Service: job app 123, reviewed, "Submit Interview", "Cancel", "Reject"
  

Understanding how to encode an imperative SOA static model to a conversational document interchange is not really that well understood yet (certainly to me). I think someday it will be, but right now there is just the quotes from the REST thesis I commented on and a reference to "data reactive programming" from Roy Fielding, and I just found Mimosa.

Just need to make sure of something about the Job Application Service example: is this service the provider or consumer of the lifecycle of a job app? It clearly has an internal state machine for job apps, but what other machine process does that get shared with?

[1] Some discussion (still searching for link...) hinted that WADL could be simply returned like an HTML Form, and not used to statically generate code. I think avoids the coupling of code-gen, but I'm not sure how it solves the problem of shared understanding either.