Telecommuting / working remotely / working from home – these are various terms for an increasingly popular mode of working. In this model (of working) people use the amazing ability of the internet to communicate over vast distances instantly and modern collaborative software tools to effectively work together without actually being in the same physical room, office or even city.
- No need for any commuting, one can stay close to one’s family (a huge factor if you have children) and flexible working hours. It is a more relaxed way to work. I have been working in such an environment for about a year now, and with a new baby, the lack of commute and the freedom to pop downstairs and help out in case my wife needs an extra pair of hands has been awesome!
- Another major advantage (at least for the company), is the reduced office infrastructure costs. In places where getting an office building thats a reasonably close to where your employees live is difficult, this can be a major boon. Also, not forcing your employees into having to commute is a major plus both for employee morale and the environment.
- One has the opportunity to hire and work with people from a larger pool rather than being limited by a single geographical location, like a city or state or even a country. This can be very powerful advantage, sometimes finding all the right people you need in a single location can be a major problem.
- An “advantage” that is often touted is that the geographical separation allows for better efficiency, since, theoretically, one could have employees coming online and starting their workday as others end theirs – making use of the entire 24 hours on the clock for work. I believe, at least for software development, this is a fallacy and attempts to leverage this so called “advantage” is a big reason for the failure of certain companies to successfully leverage this model of working – but more on this later…
In the software development field we have been working in such a distributed model for a long while now and I have seen this model evolve, influenced both by the advances in the technology and tools available for collaboration as well as the evolution of the software development methodology itself. I’d like to take a few lines to write about this evolution and distinguish between what I consider to be “distributed development” model and what I call “outsourced development”.
In the outsourced development model – a software project is broken up into separate well defined phases, each phase having definite outcomes with concrete artifacts (usually in the form of documents). This means that (in theory) one can easily move around parts of a project between various teams who would then rely on the artifacts produced in the previous phase to execute the next phase of the project. Other than a short period between phases, where one team handed over the project to the other, there would be very little actual interaction between teams. This form of software development follows the waterfall methodology and while it is a good fit for outsourcing, it is, in practice, prone to problems, that, for the most part arise due to a lack of communication between the various stakeholders of the project and the members of the team(s).
What I call “distributed development” (there is a more generic definition on wikipedia that is not limited to software development) is a refinement on the outsourced development approach that attempts to leverage technological advances in internet connectivity and better communication tools to try and minimise the disconnect introduced by working remotely in software teams. Distributed development places emphasis on communication and interaction between all the members in the virtual team. The idea is to reduce the feeling that we are working in different physical spaces and that everyone is off working on some discrete task on their own. This kind of thinking is in-line with the agile philosophy which emphasizes individuals and interactions over processes and tools.
- One can use many tools and technologies to do your job. But regardless of what you use, patience and trust are the biggest success factors in this kind of working. I initially put this point lower down in the list but on consideration decided that this is the most important tip. Without trust the whole thing is an exercise in futility. One needs to learn to trust in the skills of the developer to do his or her bit and the patience to listen and accept that problems and delays might happen. The best way to build trust is by having open and rich channels of communication and meeting and interacting with everyone in person.
- Reliable and fast internet is an absolute must and its not that easy to get – at least where I come from. Ask if the person you are working has a backup power supply and a good internet connection. In terms of power supply, the need for one depends a lot on the place the person is working from – if it’s a big city then usually a UPS that provides an hour of backup should be fine, unless there is chronic power problem. In smaller towns and such, they might need to have something more substantial like an inverter or a portable generator. Modern laptops with their longer battery life and portability are a major help since they allow one to ignore smaller outages and coupled with the appropriate wireless or cellular data connection can even allow you to simply shift your base of operations to other places with power and internet.
- This guideline, I think is going to be a bit controversial and is the reason I think that 24 hours work day idea I have mentioned is not really a good idea. If you have a team that spans countries and (in my case) continents, it is very important to have good overlap between your timezones – at least 4 hours of overlap is needed in my opinion, since this will allow you to actually collaborate rather than be limited to a short meeting at the beginning or end of your day. After all, developing software in a team is, in my experience, a collaborative activity, requiring lots of discussion (and argument) and having your stakeholder at hand while you work through a problem is very useful. No amount of documentation and pretty pictures can substitute someone being there, clarifying and providing context for you.
- You need to have an open channel of communication during the time of overlap while you are working – this can be as simple as an open IRC (Internet Relay Chat) channel. We use Skype at work and I think the ability to call or video chat on demand make it far superior to IRC. Another option to explore is to use something like a Google+ Hangout while you are working – obviously this will mean the both you need to have reliable high bandwidth internet. Paid options for software tools are there as well like Microsoft Lync which may be a more integrated solution if you have a Microsoft based IT infrastructure with Microsoft Exchange (I got this from the podcast – haven’t used this myself since we don’t use MS Exchange). There are variety of communicators and tools out there to tryout – have a look at this link where Scott provides a deep dive into the communications tools available for remote workers.
- Schedule regular meetings and get togethers in the real world. If this means that someone needs to travel somewhere from time to time, consider that the cost of doing distributed development. I would consider this an investment in the team’s productivity and efficiency. When everyone has met in person and worked together on issues, you build up mutual trust and respect. In my year of working at Bang the Table, I think we have had get togethers at least once every quarter. Sometimes we just got together and spent a few days simply working together with no other agenda, sometimes it was a conference or a training.
- Distributed development tends to work well with relatively flat and simple organizational structure. The idea is that everyone should feel equally invested and responsible for the software project. The challenge of course is that this particular setup does not scale very well and can be problematic for large organizations.
- A good online project management tool is a must to ensure you are heading in the right direction. We are constantly trying out new tools for this part of our development. I have found JIRA to be good for support and task based work while, I am liking Trello for more open ended new development.
- At work we use a Rackspace server as a development server and for testing. This is a machine on which we stage our commits from our local machines and have our testing done on. Having a machine to deploy your code on also forces you to test it in the right environment and also brings deployment considerations into your design and development schedule.
It’s been a fascinating experience for me – working from home and I think I have learnt a lot about the vagaries of distributed development. In fact, I have been experimenting with a more distributed approach to pair programming with a couple of friends of mine.
We used Vim in a GNU Screen session to set up a development environment that we could share between us and then while one person typed we used Skype to chat with each other. We followed the classic test driven mechanic – one person writes a test and the next person passes the test cycle. The experience was remarkably powerful, since I could see when the editor was being manipulated by the other person, the thought process going on as the code was being typed in. We built a small Python program – I came from that experience with a real appreciation of what can be done with some of the simple (and powerful) unix tools already out there.
I came across another tool Tmux which is similar to screen and is used a lot in the Mac when I was listening to this podcast on the Changelog. There is a very nice screencast showing how to use Tmux I found recently, you can checkout. I also came across this awesome website called pair.io that spins up a server for you to use in your pair programming sessions.
- Hanselman Blog – Remote Work
- Hanselminutes – The Plight of the Remote Worker with Pete Brown
- The Changelog – Tmux with Brian Hogan and Josh Clayton
- Pair Programming with Tmux – a screencast
- Bang the Table
- On working remotely
- Wemux – Tmux enhancement for remote pairing
thanks for providing us the lyrics of the song..now i am very willing to learn more about mandarin although im a filipino..hehehe..salamat.. Click http://link.mx/hool081945
Interesting stuff! I think it’s good that more people share their experiences about managing remote teams. I have written some books on the topic together with a crowd of experts: http://bridge-staffing.com/ebooks
We’ve also built a platform to make it easier to find the right remote software team: http://www.ekipa.co
Sorry for contacting you this way. I was wondering if you would be interested in
reviewing http://ubiq.co for your readers. It is a new web based MySQL reporting
tool I’ve built. Happy to provide extended free usage to your readers. Just use promo code ‘goubiq’ to get 2 months free usage.
Came across a similar post from Karthik Hariharan – http://hkarthik.me/blog/2011/12/12/beating-the-talent-crunch-with-a-distributed-team/
That’s really remarkable that Bang the Table hasn’t allowed a lack of physical presence to limit the development of strong employee bonds! The team I’m currently on uses Skype and Assembla (http://www.assembla.com) to stay organized and it works well for both communication and ticketing. Have you found that JIRA works well for you team?
Thanks for the compliment. Our company has multiple products and each product has multiple features. This leads to multiple projects running in parallel and being worked on by multiple teams. In addition we have bug fixes and patches also going on. For managing the code we have found GitHub to work very well for us, but it’s issue tracking capabilities are limited and we wanted to get an idea of our productivity.
While, I have never used Assembla, our team has tried several different tools including Pivotal Tracker (http://www.pivotaltracker.com/) , Asana (http://asana.com/) and even Trello (https://trello.com/) for various projects for issue management. We have found in JIRA (http://www.atlassian.com/software/jira/overview) the necessary flexibility – especially with Grasshopper Agile Boards – to manage our workflow.
The only downside to JIRA so far is the learning curve involved in effectively setting up all the bits and pieces – switching them on or off depending on the need for the project – but as I grow more familiar with JIRA I am sure I will find more things to complain about :-)
I have been slowly catching up with Software Engineering Radio and only heard of this (http://www.se-radio.net/2011/12/episode-181-distributed-scrum-with-rini-van-solingen/) episode last week.
I think for the most part Rini hits the nail on the head when I compare it to my experiences working with distributed teams.I really agree with the need for the team to meet face to face and interact in social settings regularly. I think a lot of companies setup distributed teams without considering and budgeting for the travel needed.
However, there are a couple of items that I would argue about –
The first one is the contention that by leveraging distributed development we can create teams that “follow the sun and work around the clock”. There is an inherent contradiction in this model since if you truly wanted to to achieve 24 hours development you will invariably have one team that is in a timezone that is so apart from the others that you cannot really schedule a standup meeting. This leads to a situation where each team would need to hand over to the next which IMO is not ideal. Another issue is that if you accept the condition of a single product owner then this model is not viable.
The second item I take issue with is the implication that it is enough to have just enough overlap between timezones that allows the distributed teams to have a standup meeting – my experience with this has been that this leads to more isolation between teams and an “us versus them” mentality. I have found that the greater the overlap in the time when the entire distributed team is working together the better the communication and cohesion in the team – I think having at least 4 hours overlap between teams leads to better team dynamics and more productivity.
There are some interesting developments in the remote pairing part of distributed development. I saw this link https://plus.google.com/104757475552569715504/posts/CehM9FAbtA7 from Avdi Grim today. It is a pointer to a project that takes the TMux client and adds some interesting modes to it.
Today I was going through some questions on Programmers Stack Exchange regarding distributed development and came across this blog post from Jeff Atwood – http://www.codinghorror.com/blog/2010/05/on-working-remotely.html
The Stack Overflow guys seem to have been doing this for awhile now, and that is reflected clearly in Jeff’s post. Interesting to see some of the commonalities and differences between mine and his posts.
True, working from home for Bang the Table is really fascinating!
Glad to hear it Ershad :-)