Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in /kunden/438911_85764/webseiten/xinfo/blog/wordpress/wordpress/wp-content/plugins/qtranslate-x/qtranslate_frontend.php on line 497

Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in /kunden/438911_85764/webseiten/xinfo/blog/wordpress/wordpress/wp-content/themes/goblog/inc/options/ReduxCore/extensions/customizer/extension_customizer.php on line 320

Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in /kunden/438911_85764/webseiten/xinfo/blog/wordpress/wordpress/wp-content/themes/goblog/inc/options/ReduxCore/extensions/customizer/extension_customizer.php on line 334

Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in /kunden/438911_85764/webseiten/xinfo/blog/wordpress/wordpress/wp-content/themes/goblog/inc/options/ReduxCore/extensions/customizer/extension_customizer.php on line 360

Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in /kunden/438911_85764/webseiten/xinfo/blog/wordpress/wordpress/wp-content/themes/goblog/inc/options/ReduxCore/extensions/customizer/extension_customizer.php on line 372

Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in /kunden/438911_85764/webseiten/xinfo/blog/wordpress/wordpress/wp-content/themes/goblog/inc/options/ReduxCore/extensions/customizer/extension_customizer.php on line 391

Warning: Parameter 2 to qtranxf_postsFilter() expected to be a reference, value given in /kunden/438911_85764/webseiten/xinfo/blog/wordpress/wordpress/wp-includes/class-wp-hook.php on line 286
Software Development | XINFO Blog

Software Development Archive

Questions to an App

As a company for app development, we get many requests and ideas concerning Apps. Therefore, we have a comprehensive overview of what is in demand on the market, and what are the customer expectations. Often, such expectations are not realistic and preclude success. We have designed a series of articles that can be read on Mobile Zeitgeist. In these texts, we have put together the most important questions that you should ask yourself before implementing an app idea.



Apple Testflight

Testflight from Apple is a program with which beta testing for iOS applications can be performed. It consists of a service, which provides the functions, and an app on the test device that interacts with the user. Testflight is especially interesting from the perspective of developers, because they get faster feedback. Also for companies, the use of Testflight is an advantage, because what helps in development increases productivity.

Testflight has been used by app developers as an beta test platform since several years. Apple bought the service this year in connection with the acquisition of Burstly, the company that originally developed the platform. Apple has redesigned the program and made it available as an integrated iOS 8 service for both developers and testers.

Certainly you’ve read some of the many news and articles about the new version 8 of Apple’s iOS, which circulated in the past few months in the media. All the new functions and applications where described extensively in these texts. In business, this is important, but equally important are things that home users mostly do not care for. These mainly include data security, a coordinated management of the mobile equipment and the software as well as an accurate measurability of productivity improvement.

SCR20146-Logos-Final-CSM_CS5_1160x403_01In the last years, XINFO has become bigger and bigger – as consequence, more employees were hired. With this, new problems showed up that we did not know before. We had more possibilities now, but the project coordination became difficult. Therefore, we introduced the SCRUM process for our software development. This process means to move away from the traditional way of planning that relies much on control and command. We want to show you what SCRUM means and whether we had success with it.

App Programming

If you think about having programmed a new app, we can recommend an article that contains all necessary information.

You find the article here at our website.

To get more information about our company, visit the XINFO website. Alternatively, you can call Mr. Moritz Biersack (089/1891 788 37), or send him an email (moritz.biersack(at)xinfo.de) – he will get back to you.

We have published an article in the new issue of mobileDeveloper (5/2012, pp. 60-64): ‘In Kontakt treten’ (Making Contact). The topic of the article is how to retrieve addresses from a mobile device in a new way (using the ContactsContract).

MobileDeveloper is one of the leading German magazines for developers who write programs for smart phones and tablet computers.


In the previous posts of this series various benefits and obstacles of agile software development for distributed (offshored) teams were shown and solutions for these problems were provided. On basis of the Eclipse development process an implementation of this variation of the original agile principles was provided and it could be seen that such an approach can be a success.

In the final post the original defined twelve principles will be evaluated and it will be determined if each of them is still applicable in such a distributed environment.

You might also be interested in the other posts of this series:
Part 1: Motivation and Challenges
Part 2: Best Practices
Part 3: Case-Study on Eclipse
Part 4: Evaluation and Summary

Evaluation of the Agile Principles within Distributed Teams

To further demonstrate the challenges and to show drawbacks of agile distributed software development the twelve agile principles[BBvB+01] will be evaluated in the following section and it will be determined if these are still applicable within distributed teams.

  1. Our highest priority is to satisfy the customer
    through early and continuous delivery
    of valuable software.[SW07, 11]

    This principle can be achieved because it might be even possible to allocate more resources (manpower) in a distributed environment than with only one site [Bat09] and classic agile models which are often limited to very small teams (e.g. crystal clear 1-6 members [Coc04, 150]). Furthermore, as previously stated, the level of excellence of each team member might be increased which also results in a higher level of quality of the software (resulting in a more valuable software).

  2. Welcome changing requirements, even late in
    development. Agile processes harness change for
    the customer’s competitive advantage.[SW07, 11]

    The reduction of costs in an off shored or outsourced environment might lead to an increased flexibility concerning changed requirements [Bat09] but additional communication is required (e.g. visits of coordinators from different teams) to ensure that the changes are understood in the right manner. This communication overhead resulting from the dispersed teams might lead to an increased delay when reacting to changes compared to a single site. Thus this principle is feasible but it with the limitation that the changes might not be processed as fast as within a classic agile software development environment.

  3. Deliver working software frequently, from a
    couple of weeks to a couple of months, with a
    preference to the shorter timescale.[SW07, 11]

    As described at the first principle more resources might be available because of the distributed teams. But as a result of the hampered direct communication between distributed teams the release cycles might be increased compared to a co-located team.

  4. Business people and developers must work
    together daily throughout the project.[SW07, 11]

    The communication between the developers of sites which are not located close to the origin of the client might be hindered or even be impossible. This can be caused by two factors. The first might be the geographic distances. If these distances are too big the clients representative might not be willing to travel – and rotate – all the way to the other sites. The second can be a result of the different time zones. If the expert from the client is not willing to travel to the different sites and wants to communicate via e.g. telephone it might be hard to find a convenient time for both sides where this communication should take place. [Fow06,Bat09] Because of these factors it is hard to apply this agile principle to distributed teams but as Mikko Korkala et al. showed in their paper it is possible within globally distributed teams to establish frequent customer communication. [KPC10] Furthermore, they pointed out the importance of this principle in an agile globally distributed context:

    […] when adopting an agile approach in the globally
    distributed context […] the company should assure that […] at
    least some representatives from the customer group is always
    involved in the agile meetings.
    [KPC10, 46]

  5. Build projects around motivated individuals.
    Give them the environment and support they need,
    and trust them to get the job done.[SW07, 11]

    As a result of the increased pool of potential employees the motivation of each team member might be increased in distributed teams. But on the other hand it might be hard to control the motivation on the different sites. [Bat09] Additionally, because of the geographically dispersed sites it might be harder to support the team members and provide the required environment which they need to be fully productive. But with some controlling overhead it is possible to apply this principle to distributed teams.

  6. The most efficient and effective method of
    conveying information to and within a development
    team is face-to-face conversation.[SW07, 11]

    It’s impossible to apply this principle to geographically distributed teams. The only solution is a trade-off by using direct communication tools such as instant messenger, telephone or a video conference. But even with this tools it might still be very hard or impossible to establish a direct communication with a different site because of the different time zones and indirect communication mechanisms must be used e.g. a Wiki. [Fow06,Bat09]

  7. Working software is the primary measure of progress.[SW07, 11]

    As previously shown with the example of Continuous Integration additional attention must be put on the test and build system so that this principle can be applied. But in general this is feasible. [Fow06,Bat09]

  8. Agile processes promote sustainable development.
    The sponsors, developers, and users should be able
    to maintain a constant pace indefinitely.[SW07, 11]

    Overall this can also be applied to distributed teams (e.g. 40 hour weeks). But due to communication with sites located in a different time zone additional exhaustion might occur which has to be taken into account by the team leaders. [Bat09]

  9. Continuous attention to technical excellence
    and good design enhances agility.[SW07, 11]

    Because of the increased level of excellence within the teams resulting from the larger pool of potential software developers this principle might even be more practicable than with a single team.

  10. Simplicity-the art of maximizing the amount
    of work not done-is essential.[SW07, 11]

    This principle is feasible [Bat09] but it requires more attention because the communication might not be as direct as it would be with only one team which could lead to duplicated work.

  11. The best architectures, requirements, and designs
    emerge from self-organizing teams.[SW07, 11]

    The lack of face-to-face communication, the different cultural backgrounds of the teams and different holidays within the countries can result in a hindered self organization of the teams. To ensure a proper self organization additional measures have to be taken such as regularly exchanging developers between the teams and continuous awareness by the team members of the different cultural aspects. [Fow06,Bat09]

  12. At regular intervals, the team reflects on how
    to become more effective, then tunes and adjusts
    its behavior accordingly.[SW07, 11]

    Besides the already mentioned communication complications the application of this principle can also be hindered by unawareness of the cultural differences. If this challenge is not faced with the proper commitment activities like the retrospective where the whole team contributes to a process improvement will be hard to be realized successful [SW07,Fow06]. So to make this principle feasible within distributed teams the members with a different cultural background have to be introduced into these new aspects of the agile approach and then be encouraged to apply them.


It should be clear by now that there are several agile principles which are not applicable or limited when developing in distributed teams. These missing or restricted principles lead to many different challenges – where the main challenge lies within communication hindrances resulting from the lack of face-to-face communication and the physical dispersed teams – which makes it hard to apply agile principles to distributed teams. But when additional practices are introduced into the agile software development process it is possible to extend the classic co-located agile development to distributed teams. These additional practices are no replacement for the original practices but when followed with commitment and discipline a sufficient trade-off can be achieved. Especially the establishment and maintenance of communication channels is one key aspect of success in a distributed agile development process.

When a company introduces agile software development methologies to distributed teams they will face risks associated with this approach as Ade Miller concludes from the experiences of his team:

the decision maker(s) must understand that in doing so [distributing the project] they reduce the project’s likelihood of success, increase the delivery time, and reduce the team’s performance and increase its dysfunction. [Mil08, 18]

But the company can also profit from various advantages like the possibility to step into new markets or to increase the level of excellence within their employees.

Whether or not to use the agile methologies for distributed teams must thus be carefully balanced out for every project.


[Bat09]: Dinesh Batra. Modified agile practices for outsourced software projects. Commun. ACM, 52:143-148, September 2009.
[BBvB+01]: Kent Beck, Mike Beedle, Arie van Bennekum, Alistair Cockburn, Ward Cunningham, Martin Fowler, James Grenning, Jim Highsmith, Andrew Hunt, Ron Jeffries, Jon Kern, Brian Marick, Robert C. Martin, Steve Mellor, Ken Schwaber, Jeff Sutherland, and Dave Thomas. Manifesto for agile software development. Website, 2001. http://agilemanifesto.org/. Retrieved 28. May 2011.
[Coc04]: Alistair Cockburn. Crystal Clear: A Human-Powered Methodology for Small Teams. Addison-Wesley Professional, 2004.
[Fow06]: Martin Fowler. Using an agile software process with offshore development. Website, 2006. http://martinfowler.com/articles/agileOffshore.html. Retrieved 9. February 2011.
[KPC10]: Mikko Korkala, Minna Pikkarainen, and Kieran Conboy. A case study of customer communication in globally distributed software product development. In Proceedings of the 11th International Conference on Product Focused Software, PROFES ’10, pages 43-46, New York, NY, USA, 2010. ACM.
[Mil08]: Ade Miller. Distributed agile development at microsoft patterns and practices. Website, Article, 2008. http://www.microsoft.com/download/en/details.aspx?=amp&id=14916
[SW07]: James Shore and Shane Warden. The Art of Agile Development. O’Reilly Media, 2007.

by Kevin Kratzer


The previous post showed some additional practices for agile software development with distributed teams. This post will give you an example of a project which is successfully developed for a long time using globally distributed teams and open source contributors.
Furthermore, the main agile practices will be highlighted and the additional practices which are followed for the distributed environment will be pointed out.

You might also be interested in the other posts of this series:
Part 1: Motivation and Challenges
Part 2: Best Practices
Part 3: Case-Study on Eclipse
Part 4: Evaluation and Summary

Case Study: Eclipse [Ste04,Gam05a,Gam05b]

Eclipse LogoAn example for agile software development which is applied to distributed teams is provided by the Eclipse Foundation. This foundation is an open source community which is using agile methologies within geographically dispersed teams to develop Eclipse (http://www.eclipse.org/)which is not only an integrated development environment including a java development environment but also a general tools and integration platform which can even be used as a general application platform to develop diverse applications. The contributers to the software are not only the open source developers but also six globally dispersed teams which are located in: Canada (Ottawa, Toronto), United States (Portland, Raleigh), France (St. Nazaire) and Switzerland (Zürich).

Practices Used

The Eclipse Foundation is using various practices within the development of Eclipse:

The orange boxes highlight the involvement of distributed contributors within the development process of eclipse.

In the following sections the core practices used will be further discussed.

Key Practices Used for Agile Software Development

Continuous Testing

Testing is already taken into account early within the development cycle and these tests are then performed frequently and automated to ensure working software. The tests do not cover only functionality but also the performance.

Continuous integration

Eclipse is using an automated build and testing environment to ensure a working software. The builds are performed on a nightly, weekly and milestone basis whereas successful milestone builds are released to the community.

Incremental Design

With changing requirements the design is adjusted to the needs but these changes are limited to ensure that the public API is downwards compatible. A stable API is important for Eclipse because it focuses on extensibility using the plug-in design pattern [Fow02].

Short Development Cycles

Within the release cycle which takes 6-15 months each iteration is limited to six weeks.


After each release a so called decompression phase is performed which is time boxed to one month. Within this phase the lessons learned from the last cycle including achievements and failures are evaluated and the processes are refined accordingly. Furthermore, this phase is used to recover from the release to ensure that the developers can keep up a constant pace. In the end the next release and cycle are getting planned.

Key Practices Used for Distributed Agile Software Development

To apply the agile practices to the distributed and open source environment Eclipse is following various practices. There are three core practices which are explained in this section:


Each Milestone represents a miniature development cycle including planning, execution, testing and a retrospective. To make it easier for the distributed teams and the open source community to follow the milestone and to see the progress of the software the milestone plans are published to publicity beforehand and after the milestone is reached the results which where achieved are getting advertised.

Community Involvement (Customer Involvement)

As Eclipse is an open source project the customer of the product is the community. So it is an important part of the distributed agile development that all aspects of the development is performed in a transparent way. As a result the community can actively participate in the development and provide feedback which is taken into account by the developers to adjust the software.

Component Architecture

The whole software is splitted up into different components. These components are then assigned to specific sites (e.g. SWT is developed in Ottawa and the team in Portland is developing the debugger). By this approach the development of single components can be performed in an classic agile manner within one team and the communication need with other teams is reduced. If there are cross component problems occurring these are handled by dynamic created teams which will handle this specific problem. The members of this team are key developers of the affected components which ensures that the knowledge base of the newly created team is sufficient to understand and solve the problem.


Eclipse is following various agile principles and is applying these not only to globally distributed teams but also on an open source environment and as Erich Gamma states apparently with good success:

Throughout the history of Eclipse the development team was successful in hitting
projected delivery dates with precision and quality. [Gam05a, 4]

As a result the software development process of the Eclipse project can be counted as a successful application of the agile software development methologies in an distributed context because quality software releases can be delivered on time since the beginning in 2001.

The final post will try first to evaluate the twelve original agile principles if these are still applicable in an distributed environment and then give a small summary on the content provided in this series of blog posts on agile distributed software development.


[Fow02]: Martin Fowler. Patterns of Enterprise Application Architecture. Addison-Wesley Professional, 2002.
[Gam05a]: Erich Gamma. Agile, open source, distributed, and on-time: inside the eclipse development process. In Proceedings of the 27th international conference on Software engineering, ICSE ’05, pages 4-4, New York, NY, USA, 2005. ACM.
[Gam05b]: Erich Gamma. Agile, open source, distributed, and on-time: inside the eclipse development process. Website, Presentation Slides, 2005. http://www.icse-conferences.org/2005/ConferenceProgram/InvitedTalks/GammaKeynote.pdf. Retrieved 18. May 2011.
[Ste04]: Christoph Steind, IBM Global Services Application Management Services. Distributed agile. Website, Presentation Slides, 2004. http://cf.agilealliance.org/articles/system/article/file/1420/file.pdf. Retrieved 31. May 2011.

by Kevin Kratzer


The previous post on distributed agile software development – which can be a result of offshoring, outsourcing, multiple sites or just separated rooms within a company – discussed the benefits, motivation and the new challenges which will arise in such an environment. The follow-up post in this series will cover proven practices which can help to face these new challenges and lead to a successful project execution.

You might also be interested in the other posts of this series:
Part 1: Motivation and Challenges
Part 2: Best Practices
Part 3: Case-Study on Eclipse
Part 4: Evaluation and Summary

Best Practices

The agile manifesto describes different practices which have to be followed to ensure that the software development really is agile. With agile software development in distributed teams there are some practices which can’t be fulfilled (e.g. face-to-face communication). This problem is also stated by Ade Miller:

Agile approaches […] rely on a set of mutually supporting practices. Choosing to
drop one practice will weaken the remaining ones. Therefore when the communication bandwidth is
reduced teams must supplement weakened practices or replace them. Simply abandoning them […] will reduce the team’s level of agility.[Mil08, 7]

To avoid the weakening of other practices Martin Fowler [Fow06] and Ade Miller [Mil08] are providing solutions which have been successfully used within their distributed agile development environment. In the following the core practices which allowed this transformation of the agile methologies to distributed teams are explained and their impact on the previously shown challenges will be pointed out. These practices are meant as addition to existing agile software development methologies so that these can be used within a distributed environment.

Provide Multiple Communication Channels

As previously shown there are several challenges which arise from the communication hindrances. Because the required face-to-face communication is not possible within distributed teams it is necessary to provide multiple alternatives for this kind of communication.


A Wiki is the perfect choice to contain information which should be written down like design documents, metrics or build processes. Because Wikis are usually unstructured it is possible for them to grow with the project in an agile manner and will thus hold the information in a way which fits the teams needs the best. Additionally, the version history of documents can represent the iterative change of the project (e.g. design documents). This version history of the documents can then later on be used to extract information why specific changes were made. Another benefit of a Wiki is the change notification mechanisms like RSS which can be used to keep every team member up-to-date. However, the agile growth of the Wiki might make it necessary to assign an employee to look over the Wiki to avoid needless posts.

Instant Messenger

Instant Messenger provide three positive aspects. The first is that it is easy to determine whether a developer is currently available for questioning or not because the messenger usually provide status information about the user. This can be a great advantage when the overlapping time between two sites is limited due to the different time zones. Secondly, communication through an instant messenger is fast (synchronous) and the overhead is limited due to the informal manner of this type of communication. As a result it serves well as a replacement for the informal communication between co-located developers in a classic agile environment. The last advantage of instant messengers is that today’s clients usually support group communication which can act as a replacement for osmotic communication because all involved developers will all receive the questions and answers and might decide to actively contribute to the communication if they are familiar with the topic. This can also be achieved by chat protocols like IRC.


E-mail can be used as an addition to the instant messenger as it provides an asynchronous way of communicating information to multiple receivers. Especially when combined with newsgroups the information published can be easily accessed later on and the wanted information can be extracted.

Voice and Video

Voice (including telephone) and video chats are an important form of communication for distributed teams. It must be ensured that it is easy for the developers to use these mechanisms by providing head sets and web cams and to tell the developers that they should not be concerned about costs for the communication because the impact of missing communication would be even worse than some expenses for a telephone call. With the help of voice and video communication it is possible to organize daily meetings by providing rooms which contain cameras, microphones and a beamer where the distributed teams then can exchange important information. Furthermore, it is also possible create video recordings of meetings where one developer team could not participate to share it with them later on. By this it will be easier to catch up and no additional documents have to be created which are documenting that meeting.

Telepresence Systems

Telepresence systems are robots which are placed on a specific site and then can be controlled by an operator over the internet. These systems are often mobile and include features like microphones, speakers, a video camera and a display which shows the operators webcam picture. Using these systems an advanced version of a video conference can be achieved. Furthermore, it is possible for the operator to interact with the employees at the remote site e.g. by moving the robot to their desk. Currently, there are only few telepresence robots available but in the future more systems might be developed. [Sim11]


It is an urgent matter to make the presented communication mechanisms available directly from the beginning of the project to avoid misunderstandings. However, these mechanisms cannot fully replace the direct communication but they provide a trade-off. If possible the synchronous communication mechanisms should be used but as a result of the different time zones it might be necessary to fall back to the asynchronous communication techniques which will add delay to the development process when compared to co-located agile software development.

Travel Frequently

There are two types of visits which should be considered: co-location visits and long-term visits.

Co-Location Visits

These visits should be executed within the first few iterations of a project. The characteristic of this kind of visit is that all team members are getting assembled within on location. During that time it is possible to build trust between the – under normal circumstances distributed – teams, create bonds and establish communication channels which can later be used to avoid misunderstandings. But not only the team members should be present it is also important that the project managers and an expert from the customer are present which will provide these co-location visits a working environment which is the same as it would be within a classic agile software development process. Especially for creating a release plan and the development within the first few iterations this can have a positive impact on the quality of the created software because many key design decisions are being made at the beginning of the project and it is better if the whole team and the customer can equally contribute to these decisions. It is also possible for every team member to reduce the vagueness concerning the requirement specification which can avoid later misunderstandings.

Every few months these visits should also be repeated periodically. It is sufficient for these periodic visits to take about one week but it is also recommended to plan longer visits if bigger changes within the software are being made or if some communication problems occurred. These visits can be used to refresh the bonds and trust which is fading over time within distributed teams. Furthermore, these periodic visits are a good place to reflect on the process, the achievements and the failures and to take appropriate actions like updating the process during a retrospective.

Additionally, such a visit should also be performed during the last few iterations before shipping a release to avoid delay in the development due to communication hindrances during that important time. If the whole team is assembled after the release is shipped this visit can then also be used to perform a retrospective.

To ensure the establishment of relationships during the visit some social events should be organized and the work pace should be relaxed. Additionally, gifts representing the different culture of the visitors will also help to break the ice and will help to initiate the communication. Martin Fowler emphasizes the importance of connections on a personal level:

Dinners and sightseeing can often be the most useful activity that the visitors do with the hosts. [Fow06, #UseContactVisitsToBuildTrust]

This will allow informal communication to take place during the visit which will later pay off because more communication links will be available after the visit is over.

Co-location visits are complex and could become very costly so it might not be possible to get all developers of the different sites together. If it is not possible at least the senior developers of the different sites should perform this type of visit at the beginning of the project to ensure profound design decisions.

Long-Term Visits

The key aspect of this visit type is that on every site there is always a representative from all the other sites present. The duration of such a visit should be ranging from a few weeks up to a few months depending on the representative being exchanged. The selection of the potential representatives must take the personal needs into account because it might not be possible for some to stay abroad for a long period. The main function of the representatives is to act as a catalyst for communication. Because he is familiar with the fields of specialization of his fellow team members he can establish communication links between both sites. Furthermore, he has access to the local informal communication in that team and can extract important information which he can redirect to his site of origin. Besides the benefits of establishing communication links the representatives is also able to build up trust between the geographically dispersed team members. A long-term visit also provides the project managers a good opportunity to get to know the whole team which is important when making decisions and resolving conflicts.

Martin Fowlers team extended this approach by not just sending developers as representatives but also by exchanging analysts who can communicate the requirements between the distributed teams [Mil08, 11].

To avoid misunderstandings and a lack of trust these representatives should be always present directly after the kick-off of the project.


The presented visits should be part of the distributed agile software development to compensate the lack of face-to-face communication, provide trust between the team members, to avoid misunderstandings and to counter the as Ade Miller states ”‘Us vs. Them’ attitude

Use Iterative Documentation

One of the new challenges lies within finding the correct amount and format of the formal documentation which is required within an agile distributed software development process. Because every development environment is different it is not possible to define these parameters for every case. As a result the process of determing the required formal documentation should be performed in an iterative way. A company should start with only little documentation and constantly request feedback from the distributed teams. This feedback can then be used to adjust the amount and the format of the formal documentation in a way that it is sufficient within their specific set up. To support this agile approach all documents should be kept in a repository to make it easier for every participant to access the latest version of a specific document. Furthermore, unstructured content management systems like the previously mentioned Wiki have proven to be useful.

Continuous Integration

Continuous Integration is a practice which originated from Extreme Programming and its main goal is to avoid problems when big separated work pieces are integrated back into the system by continuously integrating small changes every few hours. To ensure that the repository does not contain code which has unresolved problems every developer should first build the code within a sandbox and validate this build by running tests. If everything went smooth the changes can be integrated back into the main repository where a build server should perform an automated build followed by tests which validate that the integration did not break the system [SW07]. Of course integration problems also exists in a distributed environment but the impacts of failed builds are even worse because a failed build can prevent a team which is working in a different time zone from further developing until the team who broke the build is back at work. This can be avoided by using continuous integration. Additionally from avoiding such development dead locks, by always committing small changes it will be easier to detect misunderstandings within the requirement specification. This can be achieved because the repository will always contain a working version of the current development status which the customer can access and check if the requirements are implemented as desired. Thus the in the agile manifesto valued customer collaboration can be improved. Another benefit of continuous integration is that the new developed functions will always be well tested which results in a higher quality of the produced code.

That is why Continuous Integration should be used when applying agile software development to distributed teams.

Distribute the Work

When distributing work to several teams it often happens that specific components are always assigned to the same team. This might work for smaller projects and – according to Conway’s Law (Conway’s Law states that the architecture of a software will reflect the organizational structures within the company [Wik11]) – will have a positive impact on the software architecture because it will reduce the degree of coupling. This approach is suggested by Martin Fowler[Fow06]. Ade Miller on the other hand points out that this kind of distribution bears a big disadvantage for larger projects. As a result of the component-wise distribution islands of expertise will be created among the distributed teams. When new requirements arise it might be hard for a team which worked always on a specific component to quickly switch to a different component to develop a new feature within this component. He states:

Distributed teams […] need to […] think in terms of user stories not system components.
[Mil08, 15]

The impact of this disadvantage is that agility within the software development is lost which should be avoided. So it is necessary to deliberate for every project about whether to use the component-wise distribution or not.

Another approach which is often used for distributed teams is the activity-wise distribution. For example this can mean that testing is done on a different site than the development. This might work well in a classic software development process but it should be avoided when agile methologies are applied to distributed teams because by first creating test cases for the requirements it is possible for the developers to deepen their knowledge and thus helps them to understand the requirements better and a lack of clarity of the specification will be detected early. Furthermore, each developer will gain a better understanding of the whole software project which will also lead to better results when developing new features.


The presented practices mainly try to replace the direct communication within the team and the customer involvement throught the whole project which are core practices used in the agile software development but which cannot be achieved within an distributed environment. Although, the practices are only a trade-off which cannot replace the original practices it is important to adapt to these new practices starting as early as possible in the project to avoid misunderstandings within the teams.
Because every team is different it is not clear if these practices will completely fit your needs. You should start of with the presented practices and evolve your own practices from them so that the practices optimally fit your teams needs.

The next post will focus on the agile practices used in the development process of eclipse which is not only developed as an open source project but also within distributed teams.


[Fow06]: Martin Fowler. Using an agile software process with offshore development. Website, 2006. http://martinfowler.com/articles/agileOffshore.html. Retrieved 9. February 2011.
 [Mil08]: Ade Miller. Distributed agile development at microsoft patterns and practices. Website, Article, 2008. http://www.microsoft.com/download/en/details.aspx?=amp%3bamp&id=14916
[Sim11]: Tom Simonite. Vertretung im Büro. Technology Review Online Article, 2011. http://www.heise.de/tr/artikel/Vertretung-im-Buero-1326762.html. Retrieved 24. August 2011.
[SW07]: James Shore and Shane Warden. The Art of Agile Development. O’Reilly Media, 2007.
[Wik11]: Wikipedia. Conway’s Law. Website, 2011. http://en.wikipedia.org/wiki/Conway2011.

by Kevin Kratzer