About: Cowboy coding is a research topic. Over the lifetime, 14 publications have been published within this topic receiving 137 citations. The topic is also known as: cowgirl coding.
TL;DR: This book combines an overview of XP, from the hand of the people who proposed it, description of experiences in specific areas yet unclear and subject to debate, and an empirical evaluation of how XP projects are progressing in software companies.
Abstract: From the Book:
Welcome to yet another book on Extreme Programming—and Agile Methodologies, of course!
Writing a book about new software development methodologies can be a very easy and a very difficult task together.
It could be very easy, as you could talk about very generic and high-level vaporware without ever entering details, and backing your approach with statements such as “it requires customization,” “no silver bullets,” and other politically correct statements.
You could take the completely opposite approach, and still have a fairly easy task if you have ever run a project with your methodology. You could enter a detailed description of what you did, distilling a complete approach around your individual idiosyncrasies. Best would be if you add something esoteric, such as typing into the keyboard with only the right hand, and using the left to hold a silk napkin with whom you would clean your sweater every other minute.
This is not because software authors are bad by nature. We should remember that in the early days of the studies in electronics, the equation for the resistor was awfully complex, with lots of terms which were really insignificant. Nowadays, it is a simple algebraic division: R=V/I.
However, writing about a new methodology becomes dreadfully difficult if you aim at creating something really valuable for the reader, combining the limited theoretical understanding with the limited experimental evidence, and avoiding a terse language.
This book takes this latter approach. We combine an overview of XP, from the hand of the people who proposed it, description of experiences in specific areas yet unclear and subjectto debate, and an empirical evaluation of how XP projects are progressing in software companies.
The first section is the overview of the methodology. We assume that you have already read the cult books, Kent’s, Martin’s, Ron’s, Jim’s, etc. So we summarize all the foundations in one chapter, by Don.
In Chapter 2, Jim Highsmith presents the essence of “Agility.” This insightful chapter goes in the depth of Agile Methodologies and explains the rationale behind any agile proposal.
The large number of Agile Methodologies may disorient software managers and engineers. To this end, Michele provides guidelines to select which among the several Agile Methodologies best suits your environment (Chapter 3).
Most likely people thinking at XP, associate it to Pair Programming. Detractors say that it is only a fad, which wastes time and money of software companies. Supporters are convinced that it is the philosopher store of software development. In Chapter 4, Laurie discusses the principles of Pair Programming, details when and how to adopt it, and summarizes the expected benefits.
An effective analysis in XP is centered in the ability to find a suitable metaphor. This is not an easy task, especially when the project gets larger and more complex. In Chapter 5, William and Steven Wake focus on the issue of metaphor. In particular, they detail their approach in finding a metaphor, in relating the objects of the system to it, and in evaluating whether there are “bad metaphors.”
XP is not cowboy coding, neither completely uncontrolled development. It is the opposite of them. But how is it possible to couple an agile approach with measurements and process control? They look like an antinomy. In Chapter 6, Giancarlo discussed possible avenues to implement an agile measurement program, taking advantage of sources of data naturally available to software engineers and managers.
What is the extent to which each individual practice of XP is useful? How much of them should we keep in our project for our project to be successful? What is the level of customization of the practices that we can safely have? In Chapter 7, Ron attempts to address these tricky issues that managers pose every day. He analyses the most relevant practices and concludes with a caveat toward to “agile” customizations.
Last but not the least, Michele explains how it is possible to hit your targets using XP. He explains how to align business and technical goals, and outlines possible problems that you may face when implementing an XP project and how to solve them.
TL;DR: One of the things the authors always try to do, no matter what design or coding techniques they’re using, is to avoid duplication of design and code.
Abstract: ion Let's change tack here and talk about a different example. Alice and Bob have just moved to a new city and need to transfer their old Second City Bank and Trust bank accounts to First Galactic Bank. Alice and Bob are typically middle class and have several bank accounts they need to transfer: a checking account, a passbook savings account, and an investment account. Nobody actually opens a generic “bank account.” Instead they open different types of accounts, and each type has different characteristics. You can write checks on a checking account, but you can’t write checks on a passbook savings account. You can earn interest on a savings account, but you normally don’t earn interest on a checking account; you pay a monthly service fee instead. But all different types of bank accounts have some things in common. All of them use your personal information (name, social security number, address, city, state, ZIP), and they all allow you to deposit money and withdraw money. So, when putting together a program that handles “bank accounts,” you may realize that there will be common attributes and behaviors among several classes. Let’s look at some classes for a bank account example. Because we know that checking accounts, savings accounts, and investment accounts are all different, let’s first create three different classes and see what we’ve got (see Figure 9-3). Figure 9-3. Bank accounts with a lot in common Chapter 9 ■ ObjeCt-Oriented analysis and design 118 Notice that all three classes have a lot in common. One of the things we always try to do, no matter what design or coding techniques we’re using, is to avoid duplication of design and code. This is what abstraction is all about! If we abstract out all the common elements of these three classes, we can create a new (super) class BankAccount that incorporates all of them. The CheckingAcct, SavingsAcct, and InvestmentAcct classes can then inherit from BankAccount. BankAccount is shown in Figure 9-4. But wait! Is the BankAccount class one that we would want to instantiate? If you look, you’ll see that each of the other classes is much more specific than the BankAccount class is. So, there isn’t enough information in the BankAccount class for us to use. This means we’ll always be inheriting from it, but never instantiating it. It’s a perfect abstract class. (Note the little bit of UML in Figure 9-5—class diagrams of abstract classes put the class name in italics.) Figure 9-4. A cleaner BankAccount class Figure 9-5. BankAccount as an abstract class Chapter 9 ■ ObjeCt-Oriented analysis and design 119 Abstract classes are templates for actual concrete classes. They encapsulate shared behavior and define the protocol for all subclasses. The abstract class defines behavior and sets a common state, and then concrete subclasses inherit and implement that behavior. You can’t instantiate an abstract class; a new concrete class must be created that extends the abstract class. As a guideline, whenever you find common behavior in two or more places, you should look to abstract that behavior into a class and then reuse that behavior in the common concrete classes. Here’s what we end up with after abstracting out all the personal data and common behavior into the BankAccount abstract class. Notice one more little bit of UML in Figure 9-6: the new UML arrow types, open arrow ends. These open arrows indicate inheritance; so the CheckingAcct class inherits attributes and methods from the BankAccount abstract class. UML calls it generalization because the super class generalizes the subclasses. That’s why the arrows point up to the super class.
TL;DR: A tool named Smart Formatter is described that allows programmers to learn coding style rules from existing source code, and apply these rules to the code under development.
Abstract: The quality of identifiers, the coding style and formatting are important aspects that influence program understandings and maintenance. This is confirmed by the presence of several approaches and tools aimed at supporting and improving the source code quality. This paper describes a tool named Smart Formatter that allows programmers to learn coding style rules from existing source code, and apply these rules to the code under development.
TL;DR: A knowledge transfer framework for secure coding practices with guidance for the development of secure software product and how the framework could be applied in the telecommunication industry is proposed.
Abstract: Building a secure software product is required understandings of security principles and guidelines for the secure coding in terms of programming languages to develop safe, reliable, and secure systems in software development process. Therefore, knowledge transferring is required and influenced to the most effective secure software development project. This paper proposes a knowledge transfer framework for secure coding practices with guidance for the development of secure software product and how the framework could be applied in the telecommunication industry. A set of knowledge transfer activities is specified which aligns for secure coding. Finally, the implementation of a knowledge transfer framework for secure coding practices could mitigate at least the most common mistakes in software development processes.
TL;DR: A tool for statistically acquiring per developer per document accountabilities and enable learning and self-monitoring processes within a development team while maintaining anonymity to a certain degree to not endanger team spirit is proposed.
Abstract: Determining responsibility for a piece of source code is difficult when software is being developed collaboratively with weak code ownership. Nonetheless, a major factor for preventing "cowboy coding" and careless development of code is liability. We propose a tool for statistically acquiring per developer per document accountabilities and enable learning and self-monitoring processes within a development team while maintaining anonymity to a certain degree to not endanger team spirit. In this paper we want to examine possible social effects on the development team that employment of our tool has.