You are viewing a read-only archive of the Blogs.Harvard network. Learn more.

Agile Context Switching

I had the pleasure of trying to work on 3 separate agile projects last sprint. I typically get 40-50 story points done in a sprint. I like to take on more than I think I can do to keep myself from letting work expand to fill time. I also had the issue of having to take on another developer’s work. Total, we promised ~80 story points.

Now, when my kid was new and I wasn’t allowed to sleep nights, I was able to cram 70-80 sps into a sprint. But sleep has made that level of productivity very hard.

I was also tasked with working offsite, organizing a community of practice, and trying to learn a very large project through “osmosis”. Which is to say, learn as much as you can without reporting time spent on it.

I have to admit, all of the work is interesting and the clients are all people I personally don’t want to let down. So it’s hard to say “forget project X”. (Which is hard to say generally when there actually is a project X.)

So with many things pulling me in many directions, my completed story points for the sprint was 33. A significant decrease in general productivity.

Context switching needs to be allocated for in sprint planning. Duh?

The trick is how much? Some people say it takes 15-30 min to effectively context switch. That’s part of it. I think the larger part is when you’re focused on one-two items, you can finish things effectively. The more items, the more you end up with partial work. Partial work is the worst time killer. You get 50% into a feature and if you have to stop and start again it magically turns into 30-40% done.

Solution? Don’t switch contexts.

Har har. Work on something to completion before switching contexts. Be strict about it.

Posted in Agile, ATG, Development, Flashcards, Harmony Lab, Quizmo. Tags: , . Comments Off on Agile Context Switching »

Flashcard Gamification

With our Flashcard application, I am trying to make gamification a focal point. I want the games to be modular so anyone can create new games and I want games that are multiplayer. Friendly competition within the class would be ideal.

Competition among a scoring system is too antisocial. The score scroll at the end of a game of donkey kong doesn’t make for a lot of interest in this day and age.

I have a couple of ideas.

A “card” game. Each student is dealt the same 5 cards from a “deck”. They see only one side of the 5 cards. The reverse of one of those cards is displayed and the first student to select the correct card gets a point. That card is then replaced with a new one. Having them both have the same cards takes any chance out of the game. It is time based, which means it is reliant on students being on at the same time.

So a variation of the previous could be one student plays and waits for the other student to play and they don’t lose a point unless they get it wrong. Players could be matched based on how much they’ve studied.

But is that fun? I think after a while, most people would just get bored of it.

Word games on phones are quite popular, but they’re all just variations of word scrambles, word finds, or crosswords. These are simple and not very applicable to a flashcard framework.

I stopped writing this and don’t have the motivation to continue, so I’m just going to post what I have.

Posted in ATG, Flashcards, Gamification, Trends. Tags: . Comments Off on Flashcard Gamification »

Avoiding Page Reloads

My applications are part of a framework (LMS) that load a billion extra items on each page load.

To get around it I wanted to do that silly “twitter thing”. They’re the ones who get credited with it because for years normals were baffled by their url changing.

http://www.adequatelygood.com/2011/2/Thoughts-on-the-Hashbang

Additionally, if you’re interested in why the bang(!) is necessary, it’s not. It’s just to tell google to index the page. Otherwise they assume it’s just an anchor link.

https://developers.google.com/webmasters/ajax-crawling/

So I spent the last few hours changing all links in one of my current applications to do a “hashbang” sort of call instead of loading new pages. This significantly increased speed when using our clunky LMS.

This was especially annoying because our LMS forces changes with <a> tags.

What made this especially easy to implement was that I had already made all links go through a smarty plugin so altering all links in the application was just in one file and I could make those links specific to whatever authentication scheme / LMS the application is living in. So I just had to alter that plugin and the LMS specific layout and bam. The only thing that’s not covering is form submissions. But there are only a couple of those, so I’m not going to stress about that.

In continuing research obviously I had to investigate why twitter moved away from hashbangs.
http://engineering.twitter.com/2012/05/improving-performance-on-twittercom.html

The highlight of that being that with hashbangs, you have to go to the client and then back out, which reduces speed on the initial pageload. So twitter went a little fancier 6 months ago and used the history api’s PushState.

Implementing the hashbang urls was a very small amount of code, so I’m going to move forward with that for now, maybe next time I get a chance to do some research I’ll focus on converting that to PushStates.

Harmony Lab

One of the nice things about my job is being able to take credit for interesting student projects. We’ve got an awesome pool of kids that are always doing stuff. They have cool ideas, write up a sloppy implementation and don’t want to maintain it. So it comes to us and we have the opportunity to polish it and expand it for use to a broader audience.

The most recent of these projects to come along is the newly named “Harmony Lab”. (Formerly GoFigure / Piano Lab) This is a nice application that allows you to hook up a midi keyboard to your computer and get information about music theory stuffs (and by “music theory stuffs” I mean I haven’t yet wrapped my head around everything the application does).

Currently it is an application that uses an applet to get the midi data from the keyboard and a ton of javascript for visualizing the key/chord. And a ton of javascript is never a pretty thing.

We are giving it a backend for some authentication, cleaning up the javascript where we can, and adding some extra functionality — hopefully not too much extra. This is a cool project, but it’s usefulness is limited to one or two classes.

What’s cool about this is it’s a (potentially) simple application so it lets us play with (learn) something new (to us). So we went for python Django.

It’s available on github from the start.

Posted in ATG, Harmony Lab. Tags: , , , . Comments Off on Harmony Lab »

Gamification in Software Development


Gamification has been on my mind a lot lately.

I was just doing some of my sprint planning and found myself filling out borderline excessive github issues for my project. I put all of the issues for the current sprint into aptly named milestones. So as I finish the issues in the milestone, the milestone progress bar gets filled up. I recently realized I enjoy doing this because it’s very game-like.

I’ve turned work into a game and I think it has increased productivity and general happiness with employment. Maybe that sounds lame, but it seems true in my case, I would recommend it for most people who are finding their current work stale and are looking for some self motivation.

Posted in ATG, Development, Gamification. Tags: , , , , , . Comments Off on Gamification in Software Development »

Agile Documentation and Research Stories

A few months into our switch to a more agile process, it became apparent that we still weren’t able to find a place for documentation in our sprints.

At first we had the idea that we would add a task to each story that would cover documentation. We found that we would end up writing docblocks and general code documentation but actual user documentation never got written. But we did that before so we really weren’t getting done what we were trying to get done.

Our next attempt was to set aside a day at the end of the sprint where we would write documentation or finish up stories that were not done yet. But I’m not sure how other people are doing point allocation in sprint planning but I think the ideal is to try to go just a little over the to of what you’re capable of. That keeps you working hard. At least for me, if I know I can do 50 points in a sprint and I schedule 40, I will get 40 done. Work expands to fill time. My point is there is always work to get done on the last day of a sprint. Scheduling documentation within the sprint separate from story points just doesn’t work.

That brings us to documentation stories.
As a developer
I need to document this functionality
So I can easily refer back when there is a problem in the future

This would be great, if during sprint planning, these stories actually got priority. The client wants a cool app, they don’t care about user documentation when you could instead be giving them a bell or a whistle.

What we have had are research stories. These are stories where we investigate options. i.e.
As a developer
I want to figure out if X is doable
So I know if this technology is the right way to go

These stories come up often in our process. We typically have been simply making some notes and reporting back at the retrospective / next planning. This was fine for our purposes but then we realized we could be creating a slightly more professional looking set of notes and pass them off as user documentation.

This doesn’t cover every aspect of user documentation, but it can get a lot of useful documentation done. How did we do our ldap data? We have documentation of our options and our final choice and why.

Currently we have been writing all of these in google docs so they can be easily collaborated on. We then paste them into the project wiki. It appears to be working.

Posted in Agile, ATG, Design & Modeling, Development, Uncategorized. Tags: , . Comments Off on Agile Documentation and Research Stories »

Rendering templates obsolete?

There’s an interesting discussion on github today (courtesy of javascript weekly) about whether rendering templates and template engines in general are obsolete in today’s javascript-heavy applications. This topic seems to come up periodically, although the idea hasn’t really taken off. I think the first time I came across it was in the seaside framework, which is great by the way. I don’t have a strong opinion one way or the other, so I’ll be interested to see how the discussion develops.

Posted in ATG, HTML, Javascript, Smarty. Tags: , , . Comments Off on Rendering templates obsolete? »

Github zip doesn’t include Submodules

Seriously, what were they thinking. This completely invalidates the use of submodules. We want our code to be available without having to know git. That’s the whole reason they have the download a zip link. But not including all of the code means you have to unzip the code and then use git to get the submodules.

Submodules are great for code reuse. But if I can’t intend my project to be downloaded by people that just want to install it and not code anything while using submodules. This is horrible.

Inserting images into Github’s wiki

This is something I was not able to find clear information on. Specifically, I wanted to add a flow chart I’d created to the wiki. I’ll also be adding an ER diagram later. It’s cool to have the important development documents somewhere where they can be accessed and perhaps edited from anywhere by anyone if need be. Github has a failing in this regard I think. They should have an interface for this.

The trick of it all is the wiki is itself a git repo. What you have to do is check out that repo. In my case, my project was https://github.com/jazahn/HarvardCards. To checkout that project, you would use the command:


clone git@github.com:jazahn/HarvardCards.git .

But that’s the project. The wiki is:

clone git@github.com:jazahn/HarvardCards.wiki.git .

So you have to check that out, add the image file to it, and then you can [[add the image]] via relative path image link. https://github.com/jazahn/HarvardCards/wiki/Flashcard-Flowchart

Posted in ATG, Flashcards, Git, Version Control. Tags: , , , . Comments Off on Inserting images into Github’s wiki »

Open Sourcing Now vs Later

We decided a little while ago to open source our projects. We had people asking for it and we kept having to say “sorry, we can’t really do that”. Our software wasn’t written with the understanding that anyone would look at it ever, so like most software it was poorly documented and tightly coupled with proprietary services. So it wouldn’t really be helpful to people and we were embarrassed by our own code (as most people are).

So we decided to rewrite some of our applications and the question came up should we open source it from line one of the code or wait until we were at version 1.0. When talk first started about open sourcing everyone agreed open sourcing from line one was the way to go. We three it out on github and just worked off of that. Then people started asking to see it. And there was some delay because we needed to decide on a license. And then we had a license and no one wanted to release.

I personally wanted to tell people where the code was. That’s the point I thought. But it became increasingly important to everyone else to release a more complete project. The thinking, I believe, is that if we release something that isn’t really useful to anyone from the get go, people aren’t going to ever check back. The thinking is they’ll take one look, say “huh” and never look back.

I can understand that but I still don’t agree with it. If you wait to open source software until it’s in a state you feel comfortable with, it will just keep getting pushed back because we as developers often have a perfectionist complex. It will never be perfect though.

The solution, I believe, is documentation. Not developer documentation, but very simple user documentation that doesn’t take long to read that they can look at and get a good idea at the state of the project and he direction of the project. A properly organized issue list can be very helpful. If peole can take a look at what’s being worked on, they can get a feel for where the project is. Thankfully github facilitates all of this in one place.

Just put it out there, but make it easily understandable what he state of the project is, where it works and where it’s lacking.

Posted in ATG. Tags: , . Comments Off on Open Sourcing Now vs Later »