Release Management

Conference Presentations

Mobile App Development: It's Harder Than You Think

You're thinking of creating a mobile application to take advantage of the sky-rocketing potential of mobile phones and other smart devices. Serious and critical choices must be made. Which platforms and technologies do you support? Are web-based applications the best approach? What sort of testing will you need-from whom, when, and how much will it cost? Do you want to create applications that take advantage of the mobile platforms’ capabilities such as location-aware features? Since there are at least fifteen major platforms, including several that use disparate semi-proprietary programming languages, making the right decisions early is critical. Wrong decisions will result in wasted time, effort, and money and increase the likelihood of failure.
Julian Harty, ebay, Inc.
Coding for Keeps: How to Write a Function

Functions are the basic building blocks of computer systems. Object-oriented classes are a way of packaging functions with shared data. Inheritance and polymorphism essentially are all about finding the right function. It’s all about functions! Get the picture? Chuck Allison explains that functions come in many varieties: static functions, polymorphic functions, generic functions, nested functions, higher-order functions, generator (aka stream) functions, coroutines, function closures, delegates, etc. Functions can handle arguments in different ways: by value, by result, by reference, by sharing, and by need, to name a few. Do you know how and when to use which? Functions should also be resource-friendly and robust should something hit the proverbial fan. Are your functions error-safe? Reusable? Maintainable? Do you know-really know-how to write a function? Come join Chuck and find out.
Chuck Allison, Utah Valley University
Questioning Measurement

When we consciously measure something, we try to measure precisely and often assume that our measurements are accurate and useful. However, software development and testing activities are not subject to the same kinds of quantitative measurements and precise predictions we find in physics. Instead, our work is like the social sciences, in which complex interactions between people and systems make measurement difficult and precise prediction impossible. Michael Bolton argues that all is not lost. It is possible and surprisingly straightforward to measure development and testing accurately and usefully–even if not precisely. You can measure how much time is spent on test design and execution compared with time spent on interruptions, track coverage obtained for each product area, and more.
Michael Bolton, DevelopSense
Refactoring: What You Need to Do It Right

As certain as evolving requirements lead to code changes, code changes lead to code degradation. Therefore, code refactoring is critical to the long-term viability of all software products. Kevin Sawicki shares tips and tricks for refactoring to help developers identify code that needs refactoring, preserve the correct code history during refactoring sessions, and ensure that appropriate unit tests cover the refactored code. Kevin demonstrates the Eclipse open-source frameworks and Java-based tools, including EMMA for code coverage analysis and JUnit for unit testing. These tools not only make code refactoring less painful, they also empower developers to constantly improve their code through relentless refactoring. Kevin outlines a step-by-step process to find refactoring candidates, perform the refactorings in an isolated code branch, and collaborate with other developers to review the refactored code.
Kevin Sawicki, Perforce Software
Making Agile Work in Highly Regulated Environments

Highly regulated industries-avionics suppliers, medical device companies, and pharmaceutical manufacturers-must meet rigorous quality standards to ensure their products are not a danger to the general public. Although compliance has traditionally been achieved with heavyweight waterfall or V-model development methodologies, you can implement agile-or lean-agile-development practices that adhere to standards-based regulations while reducing the risk and improving software quality and reliability. Colin Doyle identifies the constraints that agile and lean-agile software development approaches must address: traceability to clearly defined requirements, formal risk analysis and mitigation, and separation of roles between development and validation.
Colin Doyle, MKS, Inc.
Are You a Develoment Professional?

The past decade brought the rise of the Agile movement, which split into two parts-Scrum, dominating the project management practices of agile; and XP, dominating its technical practices. Of the two, Scrum has had the greater impact as the industry quickly grasped its team-based benefits. During the rapid adoption of Scrum, technical practices were not being ignored. Programmers were gradually adopting XP and related development practices. In 2008, the Software Craftsmanship movement was founded as evidenced by the Manifesto for Software Craftsmanship. Driven by the tremendous improvement in programming accuracy and style that comes from agile principles and practices, this movement strives to "raise the bar" of professionalism and quality in the software industry. We can-and must-choose the disciplines, attitudes, and practices that comprise our profession, and then we must live within those bounds.
Robert Martin, Object Mentor
The Joy of Legacy Code

Even though the code may have been written only five years ago, there it is-a sprawling unintelligible mess that nobody wants to touch. For most people and teams, this reality is a cause for fear and loathing-something we want to sweep under the rug. We can, however, choose to see “bad” code as a challenge to restructure and refactor into a maintainable design that serves the business for years to come. Although legacy code presents many constraints on design choices, it offers the opportunity for incremental improvement. Michael Feathers shows you how to practice design within the boundaries of what some see as unintelligible code and explains ways to make the improvement process manageable. See how you can escape the fear that holds you back from productive action. Find out how to start with what you have now and progress toward a structure that supports the work at hand and immediately adds value.
Michael Feathers, Object Mentor
Meet "Ellen": Improving Software Quality through Personas

Users are the ultimate judge of the software we deliver because it is critical to their success and the success of their business. However, as a tester, do you really understand their tasks, skills, motivation, and work style? Are you delivering software that matches their needs and capabilities-or yours? Personas are a way to define user roles-imaginary characters-that represent common sets of characteristics of different users. David shares how his team at Microsoft defined and used one persona named “Ellen” to help them design, develop, and test the first version of a new product. David shares before Ellen and after Ellen examples of the product, showing how the product changed when Ellen joined the team. See examples of the robust test cases and acceptance scenarios they defined from unique insights that Ellen provided.
David Elizondo, Microsoft Corporation
Applying Lean Production to Software Development: A Worldview

Lean production has made it possible for many industries to develop products faster and more profitably, building a loyal customer base while lowering business risk. Now, Lean has proven it can do the same for software development-and do so better than any development approach to date. Lean is more than a management system, method, tool, or environment; the areas where software methodologies normally focus. Lean is a worldview-a way of thinking that fundamentally changes and humanizes industry. The power of Lean is in the goals it leads us to pursue and the ways in which we coordinate our work. Therefore, Lean allows us to continue using many of our current software techniques. James Sutton returns to the beginnings of Lean, as conceived in the mind of W. Edwards Deming, and moves forward in time to compare and contrast Lean with agile development.
James Sutton, Lockheed Martin
Creating Habitable Code

A major challenge for software organizations is to create software that can continue to adapt and change over time-a codebase the team can live with "forever." Jeffrey Fredrick and Paul Julius review the concepts and features of CruiseControl, a popular continuous integration tool that provides an architecture for habitable code. CruiseControl is an open source success story, contributed to by more than 200 different developers and downloaded more than 400,000 times. For developers who are tired of brittle code that often must be discarded and rewritten instead of reused, CruiseControl provides valuable lessons and a design that encourages reuse. Jeffrey and Paul discuss inversion of control, dependency injection, separation of concerns, and the role of a project architect in creating habitable code. Although the code examples will be in Java, the principles are language independent.
Jeffrey Fredrick, Independent Consultant

Pages

CMCrossroads is a TechWell community.

Through conferences, training, consulting, and online resources, TechWell helps you develop and deliver great software every day.