Pre-Conference WorkshopsMonday, December 1xUnit Test Patterns and Smells Automated unit testing is the Agile software development equivalent of "in-process inspection." In Lean Production systems it is used to prevent defects from being introduced as software is developed. xUnit is the generic name given to the family of tools/frameworks used by developers when developing automated unit tests. The community has now had enough experience with using xUnit to start cataloging "best practices" and "not so best practices" as patterns and smells. This tutorial introduces a number of these "test smells," describes their root causes, and suggests possible solutions expressed in the form of patterns. xUnit Test Patterns and Smells will be of most interest to developers, development leads, coaches and architects who want to learn how to write automated unit tests in a more cost-effective way whether they are working in a Test-Last or Test-Driven Development environment. The Attributes of Software Quality: Performance, Scalability, Reliability, Usability, and Security Software quality isn't a popular topic in computer science. When it's covered at all, it is usually solely covered in terms of software testing or, perhaps, prevention through reviews. Matt Heusser will go back to original sources on quality and apply the ideas directly to software. More than a funny presentation or fistful of clichés Matt will cover the elusive attributes of software quality, how to engineer for them—how to know when you're done and improve in your own sense of personal craft. You will leave with skills to answer tough questions like "Is the software fast enough?", "How will it perform under load?", "Are we done testing yet?" and "Is the software good enough?" Other key concepts for discussion include reliability measures, statement and branch coverage, technical debt, test case design, redundancy, and other aspects of software craftsmanship. Ten Ways to Improve Your Code No one writes perfect code: even the best developers fall into bad habits and traps. This talk illustrates blind spots and helps you write better code. It will also revitalize your relationship to code, forcing you to rethink some of the things that you take for granted. It will cover topics that range from improve the overall structure of your code, to the way you write JavaBeans, with lots of examples. Everything in this talk may not be new to you, but I guarantee that you'll see some things that will make you reevaluate the way you think about your code. Core Conference SessionsTuesday, December 2Real World Refactoring Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk shows how to make your code safer for reactoring (even if you don't have tests), how to target what needs attention, removing structural duplication, and other techniques derived from real projects. This talk provides practical strategies for real projects to effectively refactor your code. Crafting Clean Code Get ready to dive deeply into the topic of clean code by examining what makes a good function. In this talk we will look at a lot of code; some good and some bad. You will experience how such code is analyzed, critiqued, and eventually refactored. You will learn the decisions made by an expert in the field as bad code is gradually transformed into good code. How big should a function be? How should it be named? How should it be documented? How many indent levels should it have? How should it deal with exceptions, arguments, and return values. This talk is all about code at the lowest level. And yet the principles and techniques presented have far reaching implications. Planning Agile Projects Using User Stories User stories are the primary unit of functionality that agile projects use for planning purposes. Waterfall projects use a work breakdown structure (WBS); Agile projects use a feature breakdown structure to provide the equivalent breakdown of while supporting highly incremental development and deliver. User story cards don't capture requirements per se; rather, they are "An I.O.U. for a Conversation" to be held later between the product owner or onsite customer and the developers. Getting the user story granularity right is critical for successfully implementing the incremental development that ensures Agile projects deliver a continuous stream of value to the customer. Too large and they cannot be completed in a single iteration. Too small can result in too much management overhead. Partitioned the wrong way they don't provide incremental value or cannot be tested without other user stories. In this session, Gerard helps you understand the role of user stories, how they relate to story tests, and how they differ from use cases. He provides practical strategies for making them the right size to help you achieve incremental development successfully. A Primer on Agile Software Development The benefits of agile methods are becoming ever more obvious and compelling over time. In this presentation, Dean Leffingwell provides an overview of the most common and effective agile methods as well as their business benefits. The presentation includes introductions to XP, Scrum, DSDM, Open UP and Lean Software Development along with insights as to how these methods can be scaled to the demands of the large software enterprise. This presentation is intended for both managers and practitioners interested in proven methods for enhancing the productivity and quality of enterprise software development. Collaborative Leadership: A Secret to Success Pollyanna Pixton describes a new, collaborative leadership style that does not attempt to control or micro-manage. Pollyanna explains the four areas of collaborative leadership: creating an open environment where the best people can work, learning from stakeholders throughout the enterprise, prioritizing innovative solutions based on business value, and standing back to allow the team to succeed. Whether you are a product owner, project manager, customer, or an individual contributor, Pollyanna's collaborative principles will empower you and everyone on your team to become better leaders and deliver the business value that stakeholders deserve. Scaling Software Agility: Best Practices for Large Enterprises Agile methods enable faster time to market, better responsiveness to changing customer requirements, and higher quality. This session discusses how these methods are being successfully applied to enterprise-class development. You will learn how to increase the productivity of the software development process in an enterprise environment. Topics include structuring agile component teams, concurrent testing and continuous integration. This presentation will be valuable to enterprise software managers, team leads, developers, testers, and QA personnel. Crafting an Agile Adoption Strategy for Your Environment Agile software development is steadily gaining adopters and helping teams and organizations improve the way they build software. At the same time there are many failed or ineffective teams practicing so-called agile methods. Being agile is not the goal; building better software that meets the needs of its users is the objective. Your needs and environment are different than many others, so the agile practices that will give you the most bang for your buck are different also. Join us to start an agile adoption strategy tailored to your environment. Domain Specific Languages: Software in the Language of the Business Domain specific languages have been discussed for decades. Most successful languages so far have been in computer science domains, with Rails being the latest well-known example. However, the possibilities afforded by these languages are moving into the business world, driven in part by the increased popularity of languages like Ruby. This session first introduces domain specific languages and then describes various techniques for both designing and implementing them. We'll describe some characteristics of good domain specific languages and discuss the impact on the software development lifecycle implied by utilizing domain specific languages in an application. We will work through a simple example to demonstrate the various techniques for implementing domain specific languages, as well as discussing the interaction between the characteristics of languages and their implementation. So, You're Doomed: Reviving Projects in Trouble If you've been in software development for long, you've probably seen this scenario: The development team needs six more weeks, the project is due in two, and the unhappy customer needs three more features before he'll sign off. This is not a presentation on what you should have done six months ago, or how Agile techniques would un-doom you if you were only doing all of them right now. This is a directed discussion of practical things to do now to revive the project, de-stress your life, and please even your management. Wednesday, December 3Continuous Integration: From Development to Production How do you get working software into users' hands on a moment's notice? In this session, you'll learn how the practice of Continuous Integration (CI)—building software with every change—can help teams get software into production quickly. Teams can rapidly deliver high-quality software by leveraging the automated build to include processes such as database integration, dependency management, automated tests and static analysis, local/remote deployments and creating installers. By using and extending CI, teams are able to get software into production early and often so that users benefit from the frequent delivery of working software. Easy xUnit Testing with Database Dependencies Have you ever worked on a large enterprise software project (one that heavily uses a persistent store such as a database) and wanted to add xUnit tests? And did you quickly realize that it's easier said than done? Why is that? Want to learn a better way? Justin created the Dependent Object Framework open source project (the DOF) to solve just this problem. The essence is being able to atomically set up the test fixture for any test such that there are no assumptions on the existing state of the persistent store. Additionally, one needs to cleanly isolate which persistent objects will be shared between tests versus which ones will be modified and used only within a given test. Come to this session and learn how the DOF will transform the way your team writes xUnit test cases. Project Management Techniques for Individual Contributors There are so many courses and sessions for project managers—from how to calculate earned value to figuring out the critical path to leading teams. But what about techniques for individual contributors on teams? Attend this session to learn how to pick the right tools for you and your teams, eliminate needless status meetings, and deliver a stellar product demo and other project management tips and techniques for the individual. Take control of your projects and your time! Ten Terrific Transition Tips In this talk, Josh will share ten valuable insights distilled from a decade of helping people successfully and unsuccessfully transition to Agile methods at organizations large, small and distributed. You will leave knowing about the importance of readiness assessments, the benefits of combining managerial and technical practices, different transition strategies, Agile myths, Agile metrics and results from real projects, the importance of project community, why failing fast is so important, and much more. Expect lots of stories, images, videos and other highly sticky pieces of knowledge that will serve you well in your own transition work. Planning Your Agile Testing: A Practical Guide Traditional test plans are incompatible with Agile software development, but how do you figure out what types of testing activities will be needed for an Agile software release, and when to do them? How and when do you plan testing tasks? Developers are from Mars, Users are from Venus John Gray's book Men are from Mars, Women are from Venus, with over 14 million copies sold, is firmly cemented in our contemporary vernacular. And so it offers us a starting point for how to talk about software development. How can Gray's simplifications about planetary communication problems apply to our world of software product delivery? How can we as developers and users move past "The Blame Game"? Given those challenges, Jean will propose how we can use collaboration in the software development context to overcome the narrow and unattractive attributes we tend to ascribe to our colleagues. We will look at how to bring out the greatest insights from both sides, gain consensus, manage conflict, and then continually inspect and adapt our approach. In this way, we can move throw out the self-help books with their stereotypes and move toward a real world approach for working with our brothers from a different planet. Janet Gregory will explain how to help your team understand your testing needs as you plan your next release. You'll learn how to figure out who does what testing, when. Janet will show not only how to drive development with business-facing tests, but how to use testing to learn more about the system and drive future requirements. In this session, Janet will cover:
Thursday, December 4Revisiting the Future Despite ongoing advances in the industry, the software crisis continues to plague software development as new demands and capabilities outstrip our ability to engineer solutions. Software development took a turn in the early 70s from mathematical discipline to craft and often appears more organic than designed. This talk proposes we build a new foundation for computer science as a hard science to tackle the systemic problems. Virtually Free: Unchain Your Software from Its Hardware Virtualization breaks down the walls between software and hardware. More than just a back-room server technology, virtualization enables you to run your Windows development suite, test your software with your Mac's web browser, and connect everything up to a Linux web server and database—all on one laptop you can take anywhere. Join Ben to learn how you can take advantage of virtualization to unchain your software from its hardware and make easy work of formerly-hard questions, from the design phase (which operating system should I use?), to the development stage (do I have the right tools?), deep in testing (how can I cover this huge test matrix?), and right up through deployment (can I deliver my solution?). Only once you're freed from these mundane problems can you truly focus on the deep, fascinating problems that software engineering can solve. |
 |
 |
 |
||||||
 |
 |
|
||||||
