mohangk.org/blog

Getting Past the Pie Chart § SEEDMAGAZINE.COM
A really well written piece, using the criticism that the pie chart has received over the years to form a base guideline to measuring new fangled visualization techniques. We have always known that some visualizations are more flash (pun intended) then useful, but here there is an attempt at articulating as to why they are not useful and ways to improve them. Definitely worth the read. “Says Spence: “There is a place for tables in the world.””

Lamson: Lamson The Python SMTP Server
A mail processing framework. Allows the buidling of email applications as how web appllications are made on web application frameworks. Support for RDBMS (sqlalchemy), templates (mako) and configurable workflows. Allows for deferring to existing smtpd severs for delivering of email.

Timeline exercise result Originally uploaded by mohangk

At LCA we have been implementing the Scrum development methodology in increments.  We have slowly been embracing certain practices of the methodology over time and tweaking it where we see fit. Over the past 2 years this has seen us introduce many of the key practices such as continuous testing and integration, time boxed iterations as well as retrospectives. We have still been tweaking our approach to retrospectives, trying to determine the best way to carry them out.

Retrospective stages

Retrospectives tend to have  the following stages, setting the stage, gathering data, developing insights, deciding what to do and closing the retrospective. For those who would like to find out more I would strongly recommend the book Agile Retrospectives :  Making good teams great as a great guide on how to conduct a retrospectives and the different exercises one can employ for the different stages. We have been trying different exercises for the “gathering data” stage.

Gathering data for retrospectives

A technique we use to gather data for the retrospective  is simply getting people to reflect on the events of the sprint and to write events  that were  enjoyable, frustrating and puzzling as well as ideas they would like to see happen more, less or the same in individual index  cards. These are then pasted up on a board and serve as a starting point for the next stage of the retrospective (developng insights).

The upside of this technique:

1. Since people write things down, it is easier to get participation as opposed to people needing to speak up. This levels the playing field between the vocal and less vocal people in the group.
2. There is a focus on suggestions and ideas early. Although this seems to be jumping the gun as we are still in the data gathering phase of the retrospective, sometimes the ideas serve as an indirect way of highlighting issues or events that were problematic in a manner that does not put anyone in the spot. Secondly having some ideas up already on the board facilitated the “developing insights” portion of the retrospective. I find it a bit more natural to merge the data gathering and developing insights portions

The primary downside of this technique however is that there is no real co-relation between whats going up on the board and when it happened in the iteration. The sense of “when did this event happen and what else was going on at this point” is hard to be determined.

Timelining the sprint

Specifically to deal with the limitation of not being able to track an event against a stage in the timeline we had tried in the last retrospective the timeline exercise instead. An excellent description on how this exercise is carried out is available at thekua.com .

The upside of  doing this exercise was

1. It forced the team to pull out events and the days in the sprint they happened. Many of the team members ended up needing to look at their closed tickets for their sprint to jog their memory. We did end up with a timeline that had events corresponding to dates.
2. This more involved process also probably uncovered more events then the other data gathering exercise.

The downside seemed to be that we ended up with  ”event” only data, no ideas or suggestions. Hence we had a brainstorming session for the “developing insights” stage where I tried to get team members to voice out ideas, to tackle some of the challenges the timeline exercise unveiled. That turned out to be a mistake as the team did not respond to the idea of vocalizing ideas.   This of course had nothing to do with the timeline exercise itself, but having just spent 30 mins writing events down, I thought it a bit much to spend another 20 minutes writing ideas down and resorted to a vocal method. Bad idea.

Secondly because there was this implicit need to tie the ideas back to the timeline events, there was some constraint in ideas being voiced out. In the end, after much cajoling, many of the ideas put up on the board had little to do with the events in the timeline.

Lastly  the mood graph that we drew below the timeline, although interesting, did not seem to provide much value. I was hoping that it would unveil to team members mood states among one another that they didn’t expect, however that did not seem to be the case. The data seemed too blur to really derive anything solid.

Summary

All in all,  the timeline exercise  is probably more suited for teams that have members from different departments that don’t meet as much and have longer periods between retrospectives. We try to keep our sprints between 2 – 2.5 weeks (10-12 working days) and hence a simpler exercise would probably suffice. Secondly maybe the team was already too use to the old way of doing things that this new form didn’t feel as natural. Having said that, many of the team members seemed to appreciate that the retrospective exercises was varied, that by itself was valuable.

Locking for Creating and Writing Files – Zognot.org
A discussion surrounding file locking and atomicity when creating and writing files in python.

Proper file overwrites in Python – Patrice’s Weblog
A technique to implementing file overwrites that are safe using locking

BrowserCouch Documentation
CouchDB Api instead of the standard SQL api for browser storage. Looks good. Should be reasonably straight forward to implement a flash backed storage. Currently uses global storage on mozilla.

thekua.com@rest » A Retrospective Timeline
Great guide to conducting a Timeline activity during a retrospective.

We have a javascript application that uses OAuth to speak to some of our backend web services. Everything worked fine in our test environment, but when accessed from the customer site we were having intermediate problem where the OAuth authenticated requests (they were XHR requests) were being denied. This turned out to be happening because the Authorization headers that were suppose to contain the OAuth parameters were sporadically being dropped.   Mind you the customer was using IE6, however we had tested the application onIE6 prior to that and we had not experienced such behaviour. With no way to simulate the problem offsite we had to go onsite.

At the client sites it was discovered that their Internet connectivity was behind a corporate proxy. Thanks to the great IE plugin iehttpheaders by Blunk Software we were able to look at the request and responses headers on the browser.

Request 1

This is the request after completing the OAuth dance. Notice the OAuth parameters in the Authorzation headers.

GET http: //somehost.com/someapp/index?some_value=some_query HTTP/1.0
Accept: application/json, text/javascript, */*
Accept-Language: en-us
Referer: http://somehost.com/test.html
Authorization: OAuth realm="http://somehost.com/",oauth_consumer_key="key",
oauth_token="0ca1a675c6bb4ae394069b3e240b6197",oauth_signature_method="HMAC-SHA1",oauth_signature="HgGi6izQbRPnDaoarKkk2itfg4s=",
oauth_timestamp="1235464028",oauth_nonce="bzSgtifUd6",oauth_version="1.0"
x-requested-with: XMLHttpRequest
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; GTB5; .NET CLR 2.0.50727)
Host: somehost.com
Proxy-Connection: Keep-Alive

Response 1
Many requests like this might of preceded this particular requests successfully. However this requests happens at the point where (we believe) the proxy session has expired. Hence we get a challenge from the proxy.

HTTP/1.1 407 Proxy Authentication Required
Proxy-Authenticate: NTLM
Proxy-Authenticate: BASIC realm="Bobo Domain Username and Password"
Cache-Control: no-cache
Pragma: no-cache
Content-Type: text/html; charset=utf-8
Proxy-Connection: close
Set-Cookie: BCSI-CS-863E59BB9B98BEDA=2; Path=/
Connection: close
Content-Length: 813

Request 2
The browser responds to the authentication challenge. By this point the Authorization header has been dropped. The reason why however is lost to me as the Proxy Authentication doesn’t use that header.

GET http: //somehost.com/someapp/index?some_value=some_query HTTP/1.0
Accept: application/json, text/javascript, */*
Accept-Language: en-us
Referer: http://somehost.com/test.html
Cookie: BCSI-CS-863E59BB9B98BEDA=2; __utmc=65970999;
x-requested-with: XMLHttpRequest
Proxy-Authorization: NTLM TlRMTVNTUAABAAAAB4IIogAAAAAAAAAAAAAAAAAAAAAFASgKAAAADy==
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; GTB5; .NET CLR 2.0.50727)
Host: somehost.com
Proxy-Connection: Keep-Alive

Response 2
The server responds with a success.

HTTP/1.1 407 Proxy Authentication Required
Proxy-Authenticate: NTLM TlRMTVNTUAACAAAACAAIADgAAAAFgomimskXX4CIQeAAAAAAAAAAAIYAhgBAAAAABQLODgAAAA9LAFIARgB
UAAIACABLAFIARgBUAAEAGgBLAEYAVABBAFUAQgBVAFIAUABYAFIAMAAxAAQAEABLAFIARgBUAC4ATgBlAHQA
AwAsAGsAZgB0AGEAdQBiAHUAcgBwAHgAcgAwADEALgBLAFIARgBUAC4ATgBlAHQABQAQAEsAUgBGAFQALgB
OAGUAdAAAAAAA
Cache-Control: no-cache
Pragma: no-cache
Content-Type: text/html; charset=utf-8
Proxy-Connection: Keep-Alive
Set-Cookie: BCSI-CS-863E59BB9B98BEDA=2; Path=/
Connection: Keep-Alive
Content-Length: 830

Request 3

The initial request is made again however now without the Authorization heder.

GET http: //somehost.com/someapp/index?some_value=some_query HTTP/1.0
Accept: application/json, text/javascript, */*
Accept-Language: en-us
Referer: http://somehost.com/test.html
Cookie: BCSI-CS-863E59BB9B98BEDA=2; __utmc=65970999;
x-requested-with: XMLHttpReques
Proxy-Authorization: NTLM TlRMTVNTUAADAAAAGAAYAGYAAAAYABgAfgAAAAgACABIAAAADgAOAFAAAAAIAAgAXgAAAAAAAACWAAAA
BYKIogUBKAoAAAAPawByAGYAdABrAGEAcAB2AHgAbQAwAEsAWQBBAFAAWV5DPMLLAQwAAAAAAAAAAAAAA
AAAAAAAmZQUP+OrhQJTr8sGO5WtLNI7QyxHr8li
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; GTB5; .NET CLR 2.0.50727)
Host: somehost.com
Proxy-Connection: Keep-Alive

Response 3

And it fails.

HTTP/1.1 403 Request type not available
Date: Tue, 24 Feb 2009 08:27:06 GMT
Server: Someserver
Vary: Accept-Encoding,User-Agent
Content-Type: application/x-json
Content-length: 63
Proxy-Connection: Keep-Alive
Connection: Keep-Alive

Summary

This type of behavior is odd for couple of reasons

1. We don’t experience this in Firefox. Firefox correctly continues to pass the Authorization header in Request 3
2. The Authorization header is not even used in the Proxy Authentication process.
3. If we were to use some other header say X-Authorization (I know, I know ) the header comes out fine in Response 3.

This type of bizzare behaviour makes it even more critical that service providers ensure that all parameter transmission methods are implemented.

Gall’s law
“A complex system that works is invariably found to have evolved from a simple system that worked. The inverse proposition also appears to be true: A complex system designed from scratch never works and cannot be made to work. You have to start over, beginning with a working simple system.” Try telling that to marketing!

Do what you got to do, Najib
“The people are also fed up with the seeming lack of authority – from poor policing to fight crime and blatant corruption to demonstrations which disrupt the city – and yet many seem to escape the law.” It’s great how Wong Chun Wai lumps street demonstrations with crime and corruption. This from `the peoples paper`.