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.
This practical book includes a tutorial of the entire set of Windows and .NET APIs required to write concurrent programs. Because so much of the threading and synchronization features of the platform are Windows-general, the author, Joe Duffy, focuses first on the general behavior and then on the API details of native and managed code. Interspersed among the tutorial are many difficult-to-discover, useful insights, and internal details about how things work.
W. Richard Stevens, Bill Fenner, Andrew M. Rudoff
* *Previous editions sold over 160,000 units! Second Edition (1998) sold over 53,000 in retail alone! *Updates coverage of programming standards, debugging techniques, and covers Operating Systems including Red Hat 9, Solaris 9, HP-UX, Free BSD 4.8/5.0, AIX 5.x, and Mac OS X. *Bill Fenner (AT/T Labs) and Andrew Rudoff (SUN) carry on the tradition of this great work.
With the new C++ Standard and Technical Report 2 (TR2), multi-threading is coming to C++ in a big way. TR2 will provide higher-level synchronization facilities that allow for a much greater level of abstraction, and make programming multi-threaded applications simpler and safer. Concurrent programming is required if programmers are to take advantage of the multi-core microprocessors increasingly available from Intel and others. The new standard for C++ has extensions to the language that make concurrent programming more accessible to regular developers. As a guide and reference to the new concurrency features in the upcoming C++ Standard and TR2, this book is invaluable for existing programmers familiar with writing multi-threaded code in C++ using platform-specific APIs, or in other languages, as well as C++ programmers who have never written multithreaded code before.
Maurice J. Bach
This is the first, and still, the most comprehensive book to describe the sophisticated workings of the UNIX System V kernel--the internal algorithms, the structures that form the basis of the UNIX operating system, and their relationship to the programming interface. System programmers will gain a better understanding of how the kernel works and will be able to compare algorithms used in the UNIX system to algorithms used in other operating systems. Programmers on UNIX systems will gain a deeper understanding of how their programs interact with the system and can thereby code more efficient programs.
John Resig, Bear Bibeault
The java New I/O (NIO) packages in J2SE 1.4 introduce many new, indispensable features previously unavailable to Java programmers. These include APIs for high-performance I/O operations, regular expression processing, and character set coding. These new libraries are a treasure trove for java developers. The NIO APIs are especially valuable where high-performance I/O is a requirement, but they can also be useful in a wide range of scenarios. The new APIs let you work directly with I/O buffers, multiplex nonblocking streams, do scattering reads and gathering writes, do channel-to-channel transfers, work with memory-mapped files, manage file locks, and much more. The new high-performance Regular Expression Library provides sophisticated, Perl-like regex-processing features such as pattern matching, search and replace, capture groups, look ahead assertions, and many others. The Charset API gives you complete control over character set encoding and decoding, which are vital for properly managing the exchange of documents on the Web, for localization, or for other purposes. You can also create and install your own custom character sets. Staying current with the latent java technology is never easy. NIO, new in Java 1.4, is quite possibly the most important new java feature since Swing. Understanding it thoroughly is essential for any serious Java developer. NIO closes the gap between java and natively compiled languages and enables java applications to achieve maximum I/O performance by effectively leveraging operating-system services in a portable way. Java NIO is a comprehensive guide to the java New I/O facilities. It lots you take full advantage of NIO features and shows you how they work, what they can do for you, and when you should use them. This book brings you up to speed on NIO and shows you how to bring your I/O-bound Java applications up to speed as well. Java NIO is an essential part of any Java professional's library.
Jesse Liberty, Paul Betts
Tugberk Ugurlu, Alexander Zeitler
Pro ASP.NET Web API shows you how to build flexible, extensible web services that run seamlessly on a range of operating systems and devices, from desktops to tablets to smart phones—even the ones we don’t know today. ASP.NET Web API is a new framework designed to simplify web service architecture. So if you're tired of interoperability issues between inflexible web services and clients tied to specific platforms or programming languages, or if you've ever struggled with WCF, this book is for you. In Part I, you'll get up to speed on Web API's modern HTTP programming model, REST and your hosting options. Part II takes you through building a real application so you can see straight away how to put this new technology into practice. The second half of the book features dedicated chapters on topics like routing, controllers, validation and tracing, and the authors close with discussions on performance, security and an all-important look at unit testing to help you prepare your application for the real world. ASP.NET Web API makes HTTP a first-class citizen of .NET. With Pro ASP.NET Web API, you can build HTTP-based web services for your company or business, expose your data to the world across different formats and devices and gain the best possible global reach for your application. What you’ll learn The basics of HTTP web services How to build HTTP-based web services on the .NET platform In-depth knowledge of ASP.NET Web API and its processing architecture How to Unit Test an ASP.NET Web API application Asynchronous programming with ASP.NET Web API Consuming HTTP-based web services across several different clients Who this book is for Whether you’ve previously worked with WCF or are an ASP.NET developer diving into web services for the first time, Pro ASP.NET Web API will show you a clean, modern approach to building HTTP web services.
If you're one of the many developers uncertain about concurrent and multithreaded development, this practical cookbook will change your mind. With more than 75 code-rich recipes, author Stephen Cleary demonstrates parallel processing and asynchronous programming techniques, using libraries and language features in .NET 4.5 and C# 5.0. Concurrency is becoming more common in responsive and scalable application development, but it’s been extremely difficult to code. The detailed solutions in this cookbook show you how modern tools raise the level of abstraction, making concurrency much easier than before. Complete with ready-to-use code and discussions about how and why the solution works, you get recipes for using: async and await for asynchronous operations Parallel programming with the Task Parallel Library The TPL Dataflow library for creating dataflow pipelines Capabilities that Reactive Extensions build on top of LINQ Unit testing with concurrent code Interop scenarios for combining concurrent approaches Immutable, threadsafe, and producer/consumer collections Cancellation support in your concurrent code Asynchronous-friendly Object-Oriented Programming Thread synchronization for accessing data
Karel Kurst-Swanger, Jacqueline L. Petcosky
Violence in the home is one of the most damaging and widespread of social problems. It is an issue that cuts across all socioeconomic, racial, ethnic, gender, and age boundaries. It takes many forms, including emotional, physical, and sexual abuse as well as neglect. This important book reviews the most current theoretical explanations of family violence and then links theory to practice. It looks at the systems and institutions that interact with families, which are mandated to provide protection and services, and explores the current debates surrounding family violence and public policy. In addition, Kurst-Swanger explores the role of power in abusive relationships and considers the short- and long-term consequences of abuse. This insightful book will be a practical resource for professionals and of interest to all those concerned with the far-reaching impact of family violence.
Tomasz Nurkiewicz, Ben Christensen
In today’s app-driven era, when programs are asynchronous and responsiveness is so vital, reactive programming can help you write code that’s more reliable, easier to scale, and better-performing. With this practical book, Java developers will first learn how to view problems in the reactive way, and then build programs that leverage the best features of this exciting new programming paradigm. Authors Tomasz Nurkiewicz and Ben Christensen include concrete examples that use the RxJava library to solve real-world performance issues on Android devices as well as the server. You’ll learn how RxJava leverages parallelism and concurrency to help you solve today’s problems. This book also provides a preview of the upcoming 2.0 release. Write programs that react to multiple asynchronous sources of input without descending into "callback hell" Get to that aha! moment when you understand how to solve problems in the reactive way Cope with Observables that produce data too quickly to be consumed Explore strategies to debug and to test programs written in the reactive style Efficiently exploit parallelism and concurrency in your programs Learn about the transition to RxJava version 2