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.
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
Comprehensive, complete coverage is given of Windows programming fundamentals. Fully revised for Windows 98, this edition covers the basics, special techniques, the kernel and the printer, data exchange and links, and real applications developed in the text.
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).
Rob Bovey, Stephen Bullen, Dennis Wallentin
A guide to the development aspects of Excel covers such topics as building add-ins, creating custom charts, using class modules, handling errors, controlling external applications, and programming with databases.
Eric Carter, Eric Lippert
The definitive Microsoft insider's guide to solving real problems with Visual Studio Tools for Office 2007 * * Builds on the #1 book on Visual Studio Tools for Office: thoroughly revised to reflect Office's new interface, Outlook's revamped object model, and much more. * Includes authoritative guidance on using powerful new features ranging from LINQ to OpenXML * By the lead developer on Microsoft's Visual Studio Tools for Office team. This book is the definitive book on VSTO 2008 programming, written by the inventors and lead developer of the technology. VSTO is a set of tools that allow professional developers to use the full power of Visual Studio to put code behind Excel, Word, Outlook, and InfoPath. VSTO provides functionality never before available to the Office developer. For the first time, VSTO 2008 is now an integral part of Visual Studio; previous versions were available only as add-ons. This should increase the use of VSTO greatly. The authors know this technology as no one else does, and have put together as comprehensive a guide to it as possible. Not only do they provide extensive practical examples, they also explain the 'why' behind things. They cover all the new features of Office 2007 and Visual Studio 2008, including integration with WPF, WF, and LINQ. This is the only book professional developers will need to take full advantage of VSTO, whether they are new to VSTO or are experienced with older versions of VSTO.
Chris Tavares, Brent Rector ATL internals, Kirk Fertitta
The Active Template Library (ATL) is a set of small, efficient, and flexible classes created by Microsoft that facilitate the creation of interoperable components for developing Windows applications. The latest version of ATL is version 8, released with Visual Studio 2005. While .NET has been getting all the attention recently, there is still a huge base of installed COM/ATL code. Many programmers are dealing with difficult issues adding new .NET code to that installed base. At the same time there are many instances where ATL is still the superior choice for new applications - applications that have to run fast and efficiently on Windows, where the CPU doesn't have the memory or bandwidth to run .NET. This book will be a godsend to developers in both of those situations. As one tech reviewer put it, "Any programmer needing to transition ATL code to .NET will need this book." The first edition was widely praised, and sold close to 20,000 units. While ATL is no longer the cutting edge of Microsoft developer tools, there should still be a strong market for authoritative, complete, deep coverage of the newest version of this standard tool.
Brent Rector, Chris Sells
Early to market, this will be one of the first books to cover ActiveX controls and ATL and will be the first classroom-tested book on this technology. The ActiveX Template Library (ATL) is a class library for Visual C++: pre-built code modules that speed development. Using a functional approach, this book addresses the real-world choices facing Windows developers and provides practical solutions.
In Effective COM, the authors, Don Box, Keith Brown, Tim Ewald, and Chris Sells, offer 50 concrete guidelines for creating COM based applications that are more efficient, robust, and maintainable. Drawn from the authors' extensive practical experience working with and teaching COM, these rules of thumb, pitfalls to avoid, and experience-based pointers will enable you to become a more productive and successful COM programmer. These guidelines appear under six major headings: the transition from C++ to COM; interfaces, the fundamental element of COM development; implementation issues; the unique concept of apartments; security; and transactions. Throughout this book, the issues unique to the MTS programming model are addressed in detail. Developers will benefit from such insight and wisdom as: Define your interfaces before you define your classes (and do it in IDL) Design with distribution in mind Dual interfaces are a hack. Don't require people to implement them Don't access raw interface pointers across apartment boundaries Avoid creating threads from an in-process server Smart Interface Pointers add at least as much complexity as they remove CoInitializeSecurity is your friend. Learn it, love it, call it Use fine-grained authentication Beware exposing object references from the middle of a transaction hierarchy Don't rely on JIT activation for scalability and much more invaluable advice. For each guideline, the authors present a succinct summary of the challenge at hand, extensive discussion of their rationale for the advice, and many compilable code examples. Readers will gain a deeper understanding of COM concepts, capabilities, and drawbacks, and the know-how to employ COM effectively for high quality distributed application development. A supporting Web site, including source code, can be found at http: //www.develop.com/effectivecom. 0201379686B04062001
It is difficult to just throw out all existing code and start over when a new technology arrives. That’s the situation with Microsoft .NET, which represents a new and improved way of developing software for the Windows platform. Wouldn’t you would love to rewrite all of your existing code in the newer managed code environment that .NET provides? However, you have that little problem known as legacy code. Fortunately, Microsoft .NET provides a rich set of tools interoperation with existing code. This book is written as a guide for Windows developers transitioning from native Windows code to .NET managed code.
OLE is a unified and extensible environment of object-based services with the overall purpose of enabling rich integration between components. As Microsoft's object technology, it represents major innovations in object-based programming, making it possible to create applications and software components with unprecedented capabilities. But with this power comes additional complexity and new programming paradigms. Inside OLE provides both a clear tutorial and a strong set of example programs, giving you the tools to incorporate OLE into your own development projects. Written by a member of the Microsoft OLE team, this book truly gives you the insider's perspective on the power of OLE for creating the next generation of innovative software. Inside OLE provides detailed coverage and reference material on OLE and object fundamentals: Objects and interfaces, connectable objects, custom components and the Component Object Model, and Local/Remote Transparency; storage and naming technologies: Structured storage and compound files, persistent objects, and naming and binding; data transfer, viewing, and caching: Uniform Data Transfer, viewable objects, data caching, OLE Clipboard, and OLE Drag and Drop; OLE Automation and OLE Property: Automation controllers; property pages, changes, and persistence; OLE Documents: OLE Documents and embedding containers; OLE Documents and local embedding servers; in-process object handlers and servers; linking containers; and in-place activation (visual editing) for containers and objects; and OLE Controls and the future of OLE: OLE Controls, future enhancements, and component software. If you're interested in fully exploring and understanding OLE and component software, there's no better source than Inside OLE.
Sasha Goldshtein, Dima Zurbalev, Ido Flatow
Maximizing the performance of your algorithms and applications is extremely important and can give you a competitive advantage, a lower cost of ownership, and happier users. Pro .NET Performance explains the internals of Windows, the CLR, and the physical hardware that affect the performance of your applications, and gives you the knowledge and tools to measure how your code performs in isolation from external factors. The book is full of C# code samples and tips to help you squeeze every bit of juice from your application—lower memory utilization, consistent CPU usage, and fewer I/O operations across the network and disk. Pro .NET Performance will change the way you think about .NET application development. Guides you through performance measurement with a variety of profilers and other tools Explains how OS and CLR internals affect your application’s performance in unexpected ways Provides you with tips and real-life case studies for improving application performance What you’ll learn Measure your code’s performance with profilers and other tools. Understand where the bottlenecks are and focus on the right area for performance improvement. Manage memory efficiently by interacting properly with the garbage collector. Avoid common pitfalls by choosing the right abstractions. Understand the performance implications of the underlying operating system and runtime. Improve the performance of your applications by parallelization, caching, micro-optimization, and other techniques. Who this book is for Pro .NET Performance is for working .NET developers who care about the performance of their applications. It requires basic familiarity with Windows and the CLR, but guides the reader along the way and does not require prior experience with any performance-measurement tools. Pro .NET Performance also offers practical tips, case studies, and low-level knowledge for experienced developers and architects. Table of ContentsChapter 1: Performance Metrics Chapter 2: Performance Measurement Tools Chapter 3: Type Internals Chapter 4: Garbage Collection and Finalization Chapter 5: Collections and Generics Chapter 6: Concurrency and Parallelism Chapter 7: Networking, I/O, and Serialization Chapter 8: Unsafe Code and Interoperability Chapter 9: Algorithm Optimization Chapter 10: Performance Patterns Chapter 11: Web Application Performance
A trainer and lecturer for Microsoft Curriculum Courses describes the foundations of interface programming, stepping readers through the specific directives in the MIDL compiler. Going from remote methods to advanced marshaling, he touches on all aspects of IDL through a practical DCOM application.