Agile development requires architects and architecture, but the current user story-centric approach ignores the qualities of systems, instead overly focusing on features and functions. Sadly, developers who depend primarily on stories miss enormous value-creation opportunities for stakeholders. Developers often think system qualities (non-functional requirements) are someone else's responsibility to define. Even when defined, these qualities are typically not quantified, instead specified with vague terms such as "faster" and "better". Ryan Shriver believes that architects are needed to build successful systems. Architects think like engineers and actively participate in quantifying the key system qualities and then designing to implement those qualities. Ryan demonstrates techniques architects can use that are lightweight-but-rigorous and can be applied to agile projects of any size.
Applying agile methods to legacy code is challenging. You have to live with code that is not as testable or as modular as you'd like, and you have to manage support concerns that disrupt your iteration plan-all while trying to establish new build and testing practices. Even if your project is agile, you may have dependencies on legacy projects that are not delivering at iteration boundaries. Steve Berczuk explains how to be agile with a legacy code base using design, testing, build, and software configuration management practices so that you can be agile even when your code is not. You'll leave better understanding how to balance the requirements of working with an existing code base with the desire to have a more agile development environment.
Embedded software developers face the same challenges as other software developers-unpredictable schedules, poor quality, and the problems that follow. In addition, embedded software developers must overcome the realities of concurrent hardware/software development, scarce target hardware availability, long download times, high deployment costs, as well as the challenges of testing embedded C. Test-Driven Development (TDD), a key agile practice, helps software developers improve schedule predictability and product quality; but very few embedded software engineers apply TDD to their craft. James Grenning describes the problems addressed by TDD, as well as the additional challenges and benefits of applying TDD to embedded software. He provides valuable lessons for doing TDD in the hostile environment of C. After the class, get hands-on experience with James' independent study exercise, "TDD in C".
James Grenning, Renaissance Software Consulting, Co.
Agile methods focus on creating executable code quickly and with fewer defects. But what about the database? The database is "the" component of the application that is thought to be the least agile and often excluded from agile development. Pramod Sadalage explains how the concepts of Behavior-Driven Development (BDD) can be applied to database development to drive the design of the database using executable specifications. Pramod describes how performing BDDD (Behavior-Driven Database Design) allows us to specify the behavior of the database as it is expected by the code running against the database, how BDDD allows us to easily refactor the database, and how BDDD provides an easy way to document the database design and behavior.
Since Martin Fowler completed his now-classic work Refactoring: Improving the Design of Existing Code, few programming practices have been more effective-and more controversial-than refactoring. Refactoring is effective when you study and practice it diligently. It remains controversial because many development managers think developers should be adding features, not reworking old code. J. B. Rainsberger takes you deep inside the process of refactoring, including how to start reaping the benefits of refactoring while minimizing the disruption of learning a new practice, how to safely refactor code you don't know well, and the four key elements of simple design that should guide your refactoring. He explains the hazards of refactoring, when not to refactor, and how to refactor in such a way as not to upset your boss. After this presentation, you will be able to refactor your own code more confidently and effectively.
Many processes used to implement an enterprise architecture are in conflict with the agile development approach. An effective enterprise architecture framework represents the organization as it is today and as it is envisioned in the future. However, a key agile concept is that we design and build for today-and worry about the future only when it arrives. Steven Driver has found that a small change to the Scrum process flow allows easy integration of an enterprise architecture into the agile development of new systems. The translation of enterprise architecture into application architecture requires critical touch points within the Scrum process to emphasize service-based development required within the sprints. By combining an enterprise architecture approach using SOA (service-oriented architecture) and the Scrum development methodology, an organization can achieve effective system development-in both the short and long term.
Service Oriented Architecture (SOA) has many security challenges. To address these challenges, it is not enough to set up a secure operational infrastructure. SOA security must be implemented in all key areas of software development-architecture, design, platform, governance, requirements, development, and testing. Jimmy Xu discusses today's SOA security challenges and explains why it is important to address these challenges inside software development. He presents the latest security practices: standards compliance; review of architectural blueprints and SOA platforms; secure SDLC process; threat modeling; secure coding; and security testing. This session not only prepares you to delve into the details of SOA security methodology, process, and techniques, but also gives you the background information you need to plan and scope security assurance activities in your SOA development projects
The best thing about Service Oriented Architecture (SOA) is its flexibility-a heterogeneous computing environment in which different services and service providers can use different technologies; loose coupling of components to allow any application to make use of service capabilities; and ad-hoc integration of applications within and across organizations. However, from a tester's perspective, these very advantages make the testing of Web services and SOA-based applications highly complex. Testing Web services through the front-end of applications is usually ineffective. Tracking defects to their source is difficult because of the layered application designs. Instead, you must design and execute mostly non-functional tests for compliance to standards, interoperability, security, reliability, and performance.
Before charging "full speed ahead" into the land of service-oriented architecture (SOA), you need help to ensure success and mitigate the risks inherent in such major systems changes. Jerry Smith provides proven tools for assessing SOA readiness and outlines the essential steps to implementing SOA. Jerry presents reference SOA architectures that demonstrate solid standards and specifications to compare with your implementation plans. He introduces an SOA Maturity Model to help you understand your current organizational and technological state. The SOA Maturity Model is a communications tool that outlines how the organization’s SOA implementation will evolve along both business and technical lines. Jerry outlines the various stages the model entails and how to apply it so that technical and organizational changes are easily coordinated across the enterprise.
Many who try to unit test their applications-whether using agile or traditional methods-quickly find that doing a thorough job can be difficult if the code was not designed with testability in mind. Roy Osherove describes dependency injection methods for designing APIs so that they are easier to test. He explains how design patterns can help and how to implement applications with interface-based programming. Roy shares his insight on what "evolving a design" really means in the context of test-driven development. For those who are living with legacy code, he discusses special techniques for managing and implementing unit testing. In addition, Roy discusses the build life cycle and how continuous integration fits into the mix.