Cloud computing is a paradigm that makes the notion of utility computing a reality. Instead of investing scarce capital in computing resources, IT organizations are turning to pay-for-use hardware, software, and infrastructure available through the Internet. Unfortunately, because cloud services vendors have their marketing engines further into the cloud than their technology actually reaches, there is a great deal of hype around cloud computing. Arlene Minkiewicz introduces the concepts of cloud computing, discusses the different kinds of clouds, and explores different models for employing cloud-based services. She provides insights into the benefits, challenges, and risks associated with moving development, testing, and production systems to the cloud. Explore the costs you’ll face to migrate to cloud computing and how to estimate the on-going costs associated with the utility computing model.
Testability is a key ingredient for building robust and sustainable systems. Neglecting testability during software development increases technical debt and has severe consequences on systems that are destined to operate for many years. Peter Zimmerer describes influencing factors and constraints of designing software for testability and shares his experiences on the value and benefits of testability-and the repercussions of poor testability. Using real-world projects as examples, Peter describes key factors in designing for testability-an architecture providing control and observation points, testing interfaces, built-in tests, logging and tracing, diagnosis facilities, and more. Take back a checklist of important issues, facts, and practices on designing for testability in your systems.
Every day more agile practices and styles emerge, overlap, and complete. This proliferation challenges you to choose from among XP, Scrum, Lean, Kanban or the ways of the Lean Start Up crowd. Instead of stumbling onto one path or another, come to this session where David Hussman teaches tools for assessing and designing an agile process or set of practices which speaks to your needs and constraints. David covers selecting product planning tools like user stories, iterative delivery tools like kanban boards, tracking tools like burn up and more. If you want to clear the fog surrounding what will really help you, stop in and ask your questions. You will find answers.
Finally, software testing in the cloud is not just for dreamers anymore! Join Andrew Pollner to explore why and how cloud-based testing is emerging as a viable alternative to replace or complement traditional testing platforms. Implemented properly, cloud testing offers many advantages: shifts the burden of installing, configuring, maintaining, and updating testing tools to a vendor; reduces or eliminates the need to build and maintain servers to support testing functions; expands the reach of testing across geographical locations; offers potentially limitless capacity; and more. However, with all these benefits come new challenges: determining the appropriate cloud test environment, test data security, connectivity to the environment, and others.
The cloud has rapidly gone from "that thing I should know something about" to the "centerpiece of our corporate IT five-year strategy." However, cloud computing is still in its infancy. Sure, the marketing materials presented by cloud providers tout huge cost savings and service level improvements-but they gloss over the many risks such as data loss, security leaks, gaps in availability, and application migration costs. Ken Johnston and Seth Eliot share new research on the successful migrations of corporate IT and web-based companies to the cloud. Ken and Seth lay out the risks to consider and explore the rewards the cloud has to offer when companies employ sound architecture and design approaches. Discover the foibles of poor architecture and design, and how to mitigate these challenges through a novel Test Oriented Architecture (TOA) approach.
Soon mobile devices will be able to do most everything, right? Although it's fun to talk about how much mobile devices can or will do soon, limitations and constraints remain now and will for a long time. With the lower-tier market offering scaled-down devices, even the latest generation mobile devices have hardware, network, and operating system constraints. These limitations will seriously affect the architecture, design, and testing decisions for your mobile development projects. Jacob Stevens offers a primer on the unique dynamics and constraints of these lucrative platforms. Learn about the implications of mobile platform constraints that impact development and, ultimately, your customers' experience. Discover potential failure points hidden in hardware specifications and explore the trade-offs necessary for mobile success.
The question of how much design to do up-front on a project is an engaging one. Too much design often results in overkill, complexity, and wasted work. Too little design results in insufficient system structures that require rework, additional complexity, and wasted effort. How can we know what the right balance is? Alan Shalloway shows how to use the advice from Design Patterns coupled with the attitude of not building what you don't need from Agile. The trick is in discovering what you don't know, how it may affect you, and then how to isolate these risks in your code in a simple manner. Alan describes the essence of emergent design–that is, starting with a simple design and letting it evolve as the requirements evolve. He also demonstrates how to refactor to better designs and how this is different from refactoring bad code.
Developers often run into the same issues on every project. As the software is created, design problems start to creep in-causing maintenance releases with no new features, project delays, and worse. While some of these problems can be resolved by simple refactoring, others can be fixed only by a complex code restructuring effort. But you can avoid most these issues in the first place with prefactoring-using your experiences in previous projects and the experiences of others to help in early detection of common design errors and problems.
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.
Whether you are a tester or a test manager, Jon Bach believes you have little time to do the things you want to do. Even the things on your "absolutely must do" list are competing for your limited time. Jon has a list of what he calls "half-baked" ideas on how to cope. That is, these ideas are still in the oven-still being tested. In his role as a tester and manager, Jon has learned that it's not about time management; it's really about energy management-where you focus your personal energy and direct your team’s energy. Jon shares ideas that have worked for him and some that have failed: Open-Book Testing, Dawn Patrols, Tester Show-and-Tell, Test Team Feud, and Color-Aided Design. Learn how these ideas may solve your problems with test execution, reporting, measurement, and management-all at low or no cost and relatively easy to implement.