concept developer in category software development

appears as: A developer, developers, developer, The developers, developer, developers, The developer, The developer
Agile Metrics in Action: How to measure and improve team performance

This is an excerpt from Manning's book Agile Metrics in Action: How to measure and improve team performance.

  • A developer might think that good means a well-engineered piece of software.
  • SCM is where the action is; that’s where developers are checking in code, adding reviews, and collaborating on solutions. I’ve often been on teams where it was like pulling teeth to get developers to move cards or add comments in the project tracking system, which ends up leading to a huge blind spot for anyone outside the development team interested in the progress of a project. You can eliminate that blind spot by looking at the data generated by the use of your SCM.

    Figure 4.21 shows that there weren’t many comments along with the pull requests, which implies there wasn’t much collaboration going on. Because the bug trend wasn’t changing, it looked like the changes to their process weren’t having any effect yet. The workflow itself wasn’t producing the change the development team wanted; they needed to make a bigger impact on their process. To do this they decided that developers should act like the QM team when they were put on a pull request. The perspective they needed wasn’t just “is this code going to solve the problem?” but “is this code well built and what can go wrong with it?” There was some concern about developers accomplishing less if they had to spend a lot of time commenting on other developers’ code and acting like the QM team. They moved one of their QM members over to the development team as a coach, and the team agreed that if this would result in fewer bugs then the effort spent up front was time well spent. They started taking the time to comment on each other’s code and ended up iterating quite a bit more on tasks before checking them in. A few sprints of this process resulted in the graph shown in figure 4.22.

    Figure 4.22. Everything is trending in the right direction!

    Figure 4.22 shows that as collaboration between development and quality increased—in this case shown through comments in pull requests—the number of bugs went down. This was great news for the team, so they decided to take the process one step further. The development managers brought in another member of the QM team to work with the developers on code reviews and quality checks to avoid throwing code over the wall to the whole QM team.

    A common practice in teams that use DVCSs is the idea of a pull request. When a developer has a change or a set of changes that they want to merge with the master codebase, they submit their changes in a pull request. The pull request includes a list of other developers who should review the request. The developers have the opportunity to comment before giving their approve/deny verdict. This is illustrated in figure 4.5.

    Agile ALM: Lightweight tools and Agile strategies

    This is an excerpt from Manning's book Agile ALM: Lightweight tools and Agile strategies.

    Software engineering, from a historical perspective, is a young discipline. In the early stages, software development was seen more as a factory process and not as a complex activity aimed at implementing business objectives. In recent decades, software development has been evolving, initially to make life easier for developers and finally to answer internally and externally driven needs for productivity and quality.

    Figure 3.4. Feature team and component team in coexistence. The feature teams work cross-functionally on a feature, while the component teams work on a component. A developer may work as part of the component team and additionally be drafted into a feature team to work on a specific feature. The developer may work on both teams, or may solely work as part of the feature team for a defined period. A caretaker looks out for impediments and mentors a team.

    This chapter illustrates strategies and tools for setting up controllable and highly maintainable environments that are isolated from those of other developers and production systems, and that include private workspaces (sometimes called sandboxes). But what does isolation have to do with collaborative team play? In fact, being able to work in isolation is essential for effective software development and team collaboration. Management has the obligation to foster reusability and protect investments, but it’s important for all stakeholders, such as developers, to be familiar with strategies for creating a productive development environment.

    Specification by Example: How Successful Teams Deliver the Right Software

    This is an excerpt from Manning's book Specification by Example: How Successful Teams Deliver the Right Software.

    Williams estimates that Specification by Example was one of the keys to success. In addition to ensuring higher quality, Specification by Example also facilitated trust between developers and testers.

    At BNP Paribas, the Sierra project is another great example of how Specification by Example leads to high-quality products. Sierra is a data repository for bonds that consolidates information from several internal systems, rating agencies, and other external sources and distributes it to various systems inside the bank. Various systems and organizations used the same terms with different meanings, which caused a lot of misunderstanding. The first two attempts to implement the system failed, according to Channing Walton, one of the developers on the team that helped make the third attempt a success. The third effort succeeded partially because Specification by Example enabled the team to tackle complexity and ensure a shared understanding. Product quality of the end result was impressive. The project has been live since 2005 “with no major incidents in production,” according to Andrew Jackman, a consultant developer on the Sierra project. Most people currently working on the Sierra project were not there when the project started, but the level of quality is still very high.

    Teams that work on mature products and already have a good knowledge of the target domain don’t necessarily have to run meetings or have separate conversations to discuss the acceptance criteria for a story. Developers and testers might not necessarily need to provide as much input up front into the specifications, and they can resolve small functional gaps and during implementation. Such teams can collaborate with informal conversations or reviews.

    Pair-writing:
    When: Mature products

    Even in cases where the developers knew enough to work without big workshops, teams found it useful to collaborate on writing specifications with examples.

    Analysts can provide the correct behavior but developers know the best way to write a test so that it’s easy to automate later and fits into the rest of the living documentation system.

    Andrew Jackman’s team at BNP Paribas works on a relatively mature product. They have experimented with different models of writing tests and concluded that they need to get both business analysts and developers involved in writing the tests. He says:

    “When developers were writing the tests, it was easy to misunderstand what the story is about. If you don’t have the interaction with the business analysts, it’s only the developers’ view of a thing. We moved to BAs writing the tests and that made a big difference. The challenge is when they write a story, that story might influence a number of existing tests, but they can’t foresee that. The BAs like to write a test that shows a workflow for a single story. Generally that leads to a lot of duplication because a lot of the workflows are the same. So we move bits of the workflow into their own test.”

    If developers aren’t involved in writing the specifications, they can spend more time implementing features. Note that this increases the risk that specifications won’t contain all the information required for implementation or that they may be more difficult to automate.

    Continuous Integration in .NET

    This is an excerpt from Manning's book Continuous Integration in .NET.

    Figure 1.1. In the CI process, developers check code into the version control repository. The automated CI system polls the repository for changes and then builds and tests the code. Results are posted to a feedback system where team members can see the results.

    With all these builds going on and developers having to change their routine and check in code more often, you may get objections from team members. Some common objections are as follows:

    From experience, we know that projects tend to grow. Developers have a tendency to add new lines of code to their projects. They sometimes even change old lines to fix something. Some projects exist for many years and are modified by many developers. They usually want to know what’s going on in the project. But when they change the code, they add to the project’s growth.

    But what if you’re handed a project that looks like a big ball of mud? One class may have been developed with Cobol influence and look like functional programming. Some lines may be 1,000 characters long; or a previous developer may have used one-character variable names. It’s a pain to work with smelly code. The only way out is to enforce some rules. Many software shops have written coding guidelines, but having rules doesn’t mean they’ll be obeyed. Developers are human—they’re working under time pressure, and sometimes they neglect or don’t even understand the rules. Only if the coding rules are enforced will they be obeyed. Keep in mind that you should adjust the number of rules you want to obey to the project you’re working on. FxCop and StyleCop offer hundreds of rules, and some may be more important to you than others (see Krzysztof Cwalina’s and Brad Abrams’ book Framework Design Guidelines for more on that topic).

    One way to resolve this is to have two FxCop project files: one for Debug and one for Release. If you want to vary the analysis for both scenarios (not recommended from our experience, because Release tends to be neglected by developers), it should work for you. If not, you have to use a different solution.

    Becoming Agile ...in an imperfect world

    This is an excerpt from Manning's book Becoming Agile ...in an imperfect world.

  • Business people and developers must work together daily throughout the project. This principle is careful to say business people and not the customer. In most cases, it would be impractical to work with the customer on a daily basis; but generally there are multiple business proxies. These proxies may not know everything about the customer’s wants and needs, but they usually know more about the business needs than the developers do. These proxies may be analysts, product managers, or program managers. The key is to maintain constant communication between the developers and the business people to ensure that the project never goes off track—not even for a day.
  • Figure 16.8. The team can compare capacity to estimates as they add features into the iteration. In this example, the features assigned to the iteration are almost perfect for the developers, pushing them to 98% of their capacity. But the user experience group is booked way beyond their capacity at 207%. The team can back out features to get everyone closer to 100%, or they can disregard the calculation and choose to go forward if they feel comfortable doing so.
  • Have business people and developers work together daily throughout the project.
  • 18.1.2. Have business people and developers work together daily throughout the project

    In Acme Media’s previous process, the business analysts worked with the customer to document requirements. Frequently, an internal product manager communicated the needs. After the requirements were documented, the analyst passed them to the developer and determined whether there were any questions.

    In Acme Media’s new process, the developers have already had direct interaction with the customer. The entire team participated in the feature-card exercise, and the developers gained clarity on some customer needs by asking questions directly. The customer (in this case, the product manager) will also be available during the development iterations and can clarify their needs and be consulted if issues are encountered.

    Test Driven: Practical TDD and Acceptance TDD for Java Developers

    This is an excerpt from Manning's book Test Driven: Practical TDD and Acceptance TDD for Java Developers.

    One significant part of that task is a matter of testing skills—our ability to derive test cases for the normal cases, the corner cases, the foreseeable user errors, and so forth. The way TDD can help in this regard is by letting us focus on the public interfaces for our modules, classes, and what have you. By not knowing what the implementation looks like, we are better positioned to think out of the box and focus on how the code should behave and how the developer of the client code would—or could—use it, either on purpose or by mistake.

    Figure 1.6. With incremental development—building the whole system in small increments—we are never far from an integrated, working code base. This reduces risk, because the inventory of unfinished work remains small. As we’ll learn later on, incremental development also enables effective learning through early feedback based on the customer and developers constantly seeing actual, working software.