How we did it:
For any feedback, any questions, any notes or just for chat - feel free to follow us on social networks
Michael C. Feathers
The average book on Agile software development describes a fairyland of greenfield projects, with wall-to-wall tests that run after every few edits, and clean & simple source code.
The average software project, in our industry, was written under some aspect of code-and-fix, and without automated unit tests. And we can't just throw this code away; it represents a significant effort debugging and maintaining. It contains many latent requirements decisions. Just as Agile processes are incremental, Agile adoption must be incremental too. No more throwing away code just because it looked at us funny.
Mike begins his book with a very diplomatic definition of "Legacy". I'l skip ahead to the undiplomatic version: Legacy code is code without unit tests.
Before cleaning that code up, and before adding new features and removing bugs, such code must be de-legacified. It needs unit tests.
To add unit tests, you must change the code. To change the code, you need unit tests to show how safe your change was.
The core of the book is a cookbook of recipes to conduct various careful attacks. Each presents a particular problem, and a relatively safe way to migrate the code towards tests.
Code undergoing this migration will begin to experience the benefits of unit tests, and these benefits will incrementally make new tests easier to write. These efforts will make aspects of a legacy codebase easy to change.
It's an unfortunate commentary on the state of our programming industry how much we need this book.
Ralph Johnson, Erich Gamma, John Vlissides, Richard Helm
Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves. The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently. Each pattern describes the circumstances in which it is applicable, when it can be applied in view of other design constraints, and the consequences and trade-offs of using the pattern within a larger design. All patterns are compiled from real systems and are based on real-world examples. Each pattern also includes code that demonstrates how it may be implemented in object-oriented programming languages like C++ or Smalltalk. 0201633612B07092001
This volume is a handbook for enterprise system developers, guiding them through the intricacies and lessons learned in enterprise application development. It provides proven solutions to the everyday problems facing information systems developers.
Features the best practices in the art and science of constructing software--topics include design, applying good techniques to construction, eliminating errors, planning, managing construction activities, and relating personal character to superior software. Original. (Intermediate)
This title documents a convergence of programming techniques - generic programming, template metaprogramming, object-oriented programming and design patterns. It describes the C++ techniques used in generic programming and implements a number of industrial strength components.
In designing large-scale C++ applications, you are entering a dimension barely skimmed by most C++ books, particularly considering experience with small programming projects does not scale up to larger projects. This book unites high-level design concepts with specific C++ programming details to reveal practical methods for planning and implementing high-quality large C++ systems. You will learn the importance of physical design in large systems, how to structure your software as an acyclic hierarchy of components, and techniques for reducing link-time and compile-time dependencies. Then the book turns to logical design issues--architecting a component, designing a function, and implementing an object--all in the context of a large-project environment.
Build your expertise as you move beyond the basics—and delve into the core topics of programming with ASP.NET 2.0. Useful to both experienced developers and those developing new skills, this ultimate reference is packed with expert guidance, hands-on programming instruction, and practical examples to help you advance your mastery of developing applications for the Web. Discover how to: Author rich, visually consistent pages and manage layout with themes and Master pages Create personalized pages that persist user preferences Retrieve, modify, and manage data with Microsoft ADO.NET Configure the HTTP pipeline to serve ASP.NET 2.0 pages Control program flow by tracing and handling exceptions Design caching layers and learn state management techniques to optimize application performance Manage users with membership control, registration, and authentication capabilities Build real-world data access layers using common design patterns Use custom collections with data source controls Learn the internals of grid controls PLUS—Get code samples on the Web
Krzysztof Cwalina, Brad Abrams
A new edition of this title is available, ISBN-10: 0321545613 ISBN-13: 9780321545619 "This book is an absolute must-read for all .NET developers. It gives clear do and don't guidance on how to design class libraries for .NET. It also offers insight into the design and creation of .NET that really helps developers understand the reasons why things are the way they are. This information will aid developers designing their own class libraries and will also allow them to take advantage of the .NET class library more effectively." --Jeffrey Richter, author/trainer/consultant, Wintellect "Framework Design Guidelineswill help you in two important ways. First, any .NET developer will benefit from a greater understanding of the design principles that govern the .NET Base Class Library. Second, a deeper understanding of these principles will help you to create software that integrates well with the .NET environment. Quite frankly, this book should be on every .NET developer's bookshelf." --Bill Wagner, founder and consultant, SRT Solutions, author ofEffective C# "Not since Brooks'The Mythical Man Monthhas the major software maker of its time produced a book so full of relevant advice for the modern software developer. This book has a permanent place on my bookshelf and I consult it frequently." --George Byrkit, senior software engineer, Genomic Solutions "This book is a must-read for all architects and software developers thinking about frameworks. The book offers insight into some driving factors behind the design of the .NET Framework. It should be considered mandatory reading for anybody tasked with creating application frameworks." --Peter Winkler, senior software engineer, Balance Technology Inc. "Frameworks are valuable but notoriously difficult to construct: Your every decision must be geared towards making them easy to be used correctly and difficult to be used incorrectly. This book takes you through a progression of recommendations that will eliminate many of those downstream 'I wish I'd known that earlier' moments. I wish I'd read it earlier." --Paul Besly, principal technologist, QA "Filled with information useful to developers and architects of all levels, this book provides practical guidelines and expert background information to get behind the rules.Framework Design Guidelinestakes the already published guidelines to a higher level, and it is needed to write applications that integrate well in the .NET area." --Cristof Falk, software engineer Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Librariesteaches developers the best practices for designing system frameworks and reusable libraries for use with the Microsoft .NET Framework and WinFX. This book focuses on the design issues that directly affect the programmability of a framework, specifically its publicly accessible APIs. This book can improve the work of any .NET developer producing code that other developers will use. An added benefit is a collection of annotations to the guidelines by various members of the Microsoft .NET Framework and WinFX teams, which provide a lively discussion of the motives behind the guidelines, along with examples of good reasons for breaking the guidelines. Microsoft architects Krzysztof Cwalina and Brad Abrams offer guidelines for framework design from the top down. From their long experience and deep insight, you will learn The general philosophy of framework design Principles and guidelines that are fundamental to overall framework design Naming guidelines for the various parts of a framework, such as namespaces, types, and members Guidelines for the design of types and members of types Issues and guidelines that are important to ensure appropriate extensibilityin your framework Guidelines for working with exceptions, the preferred error reporting mechanism in the .NET Framework and WinFX Guidelines for extending and using types that commonly appear in frameworks Guidelines for and examples of common framework design patterns Guidelines in this book come in four major forms:Do,Consider,Avoid, andDo not. In general, aDoguideline should almost always be followed, aConsiderguideline should generally be followed, anAvoidguideline indicates that something is generally not a good idea, and aDo notguideline indicates something you should almost never do. Every guideline includes a discussion of its applicability, and most guidelines include a code example. A companion DVD includes theDesigning .NET Class Librariesvideo series, instructional presentations by the authors on design guidelines for developing classes and components that extend the .NET Framework. A sample API specification and other useful resources are also included.
David Vandevoorde, Nicolai M. Josuttis
With the greatly increased use of templates, there is a real need in the C++ community for this information. This book is the next C++ classic, acting as both a complete reference as well as a tutorial. It emphasizes the practical use of templates, and includes real-world examples.
Katherine Sierra, Bert Bates
The Best Fully Integrated Study System Available--Written by the Lead Developers of Exam 310-065 With hundreds of practice questions and hands-on exercises, SCJP Sun Certified Programmer for Java 6 Study Guide covers what you need to know--and shows you how to prepare--for this challenging exam. 100% complete coverage of all official objectives for exam 310-065 Exam Objective Highlights in every chapter point out certification objectives to ensure you're focused on passing the exam Exam Watch sections in every chapter highlight key exam topics covered Simulated exam questions match the format, tone, topics, and difficulty of the real exam Covers all SCJP exam topics, including: Declarations and Access Control · Object Orientation · Assignments · Operators · Flow Control, Exceptions, and Assertions · Strings, I/O, Formatting, and Parsing · Generics and Collections · Inner Classes · Threads · Development CD-ROM includes: Complete MasterExam practice testing engine, featuring: Two full practice exams; Detailed answers with explanations; Score Report performance assessment tool Electronic book for studying on the go Bonus coverage of the SCJD exam included! Bonus downloadable MasterExam practice test with free online registration.
Stanley B. Lippman
There is a lot of misinformation and myth about the overhead and costs associated with C++. Now Stan Lippman, the acclaimed author of the C++ Primer, answers the call for a book that gives strategy guidelines for C++ programming. Inside the C++ Object Model explains where overhead costs reside and what they actually consist of. The author explains which parts vary by implementation and which are invariant. He tells how the various implementation models arose, points out areas where they are likely to evolve, and explains why they are what they are. This book is a must for C++ programmers who want to understand the semantic implications of the C++ object model and how the model affects their programs.
This is, quite simply, the definitive reference on the most important development in software technology for the last 20 years: object-orientation.A whole generation was introduced to object technology through the first edition of this book. This long-awaited new edition retains the qualities of clarity, practicality and scholarship that made the first an instant best-seller, but has been thoroughly revised and expanded. Among the new topics covered in depth are: Concurrency, distribution, client/server and the Internet; object-oriented databases; design by contract; fundamental design patterns; finding classes; the use and misuse of inheritance; abstract data types; and typing issues. The book also includes completely updated discussions of reusability, modularity, software quality, object-oriented languages, memory management, and many other essential topics.All software developers and computer science students, worldwide.
Shows developers how COM operates and how to use it to create efficient and stable programs consistent with the COM philosophy, allowing disparate applications and components to work together across a variety of languages, platforms, and host machines. Original. (Advanced).