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.
Thomas H. Cormen
Some books on algorithms are rigorous but incomplete; others cover masses of material but lack rigor. Introduction to Algorithms uniquely combines rigor and comprehensiveness. The book covers a broad range of algorithms in depth, yet makes their design and analysis accessible to all levels of readers. Each chapter is relatively self-contained and can be used as a unit of study. The algorithms are described in English and in a pseudocode designed to be readable by anyone who has done a little programming. The explanations have been kept elementary without sacrificing depth of coverage or mathematical rigor.The first edition became a widely used text in universities worldwide as well as the standard reference for professionals. The second edition featured new chapters on the role of algorithms, probabilistic analysis and randomized algorithms, and linear programming. The third edition has been revised and updated throughout. It includes two completely new chapters, on van Emde Boas trees and multithreaded algorithms, substantial additions to the chapter on recurrence (now called "Divide-and-Conquer"), and an appendix on matrices. It features improved treatment of dynamic programming and greedy algorithms and a new notion of edge-based flow in the material on flow networks. Many new exercises and problems have been added for this edition. As of the third edition, this textbook is published exclusively by the MIT Press.
Winner of the 2014 Jolt Award for "Best Book" "Whether you are an experienced programmer or are starting your career, Python in Practice is full of valuable advice and example to help you improve your craft by thinking about problems from different perspectives, introducing tools, and detailing techniques to create more effective solutions." --Doug Hellmann, Senior Developer, DreamHost If you're an experienced Python programmer, Python in Practice will help you improve the quality, reliability, speed, maintainability, and usability of all your Python programs. Mark Summerfield focuses on four key themes: design patterns for coding elegance, faster processing through concurrency and compiled Python (Cython), high-level networking, and graphics. He identifies well-proven design patterns that are useful in Python, illuminates them with expert-quality code, and explains why some object-oriented design patterns are irrelevant to Python. He also explodes several counterproductive myths about Python programming--showing, for example, how Python can take full advantage of multicore hardware. All examples, including three complete case studies, have been tested with Python 3.3 (and, where possible, Python 3.2 and 3.1) and crafted to maintain compatibility with future Python 3.x versions. All code has been tested on Linux, and most code has also been tested on OS X and Windows. All code may be downloaded at www.qtrac.eu/pipbook.html. Coverage includes Leveraging Python's most effective creational, structural, and behavioral design patterns Supporting concurrency with Python's multiprocessing, threading, and concurrent.futures modules Avoiding concurrency problems using thread-safe queues and futures rather than fragile locks Simplifying networking with high-level modules, including xmlrpclib and RPyC Accelerating Python code with Cython, C-based Python modules, profiling, and other techniques Creating modern-looking GUI applications with Tkinter Leveraging today's powerful graphics hardware via the OpenGL API using pyglet and PyOpenGL
Get ready to dive headfirst into the world of programming! "Game Programming with Python, Lua, and Ruby" offers an in-depth look at these three flexible languages as they relate to creating games. No matter what your skill level as a programmer, this book provides the guidance you need. Each language is covered in its own section—you'll begin with the basics of syntax and style and then move on to more advanced topics. Follow along with each language or jump right to a specific section! Similar features in Python, Lua, and Ruby—including functions, string handling, data types, commenting, and arrays and strings—are examined. Learn how each language is used in popular game engines and projects, and jumpstart your programming expertise as you develop skills you'll use again and again!
Practical Python 3 for experienced developers: use the right idioms, techniques, and features to write great code * *Written from a completely 'Python 3' point of view: teaches best practices for making the most of today's newest version of Python. *Designed to help developers get productive fast... then learn how to write any program, use any library, create any library module. *Includes expert guidance on migrating Python 2 code to Python 3. Around the world, programmers appreciate Python for its simplicity, power, expressiveness, and the sheer pleasure of writing Python code. Python 3.1 is the newest and best version of the language yet: more convenient, more consistent, and easier to use. Mark Summerfield demonstrates how to write code that takes full advantage of the latest Python 3 features and idioms. Programming in Python 3, 2/e, brings together all the knowledge needed to write programs, use any library, and even create new library modules. The book teaches every aspect of the Python 3 language. It covers all the built-in functionality, as well as key components of Python's standard library. Structured so readers can write Python programs from chapter 1, each subsequent chapter provides further depth and broader coverage. Two new chapters have been added to this edition increasing the coverage to include parsing, debugging, testing, and profiling. Readers will master Python procedural and object-oriented techniques; creation of custom modules and packages; writing and reading files; multithreading; networking; database programming; GUIs; regular expressions; application debugging, testing, and profiling; and more. Detailed appendices include coverage of migrating applications from Python 2 to Python 3, plus a complete language reference. All sample code has been tested with the final version of Python 3 on Windows, Linux, and Mac OS X.
It's easy to start writing code with Python: that's why the language is so immensely popular. However, Python has unique strengths, charms, and expressivity that can be hard to grasp at first -- as well as hidden pitfalls that can easily trip you up if you aren't aware of them. Effective Python will help you harness the full power of Python to write exceptionally robust, efficient, maintainable, and well-performing code. Utilizing the concise, scenario-driven style pioneered in Scott Meyers's best-selling Effective C++, Brett Slatkin brings together 53 Python best practices, tips, shortcuts, and realistic code examples from expert programmers. Through realistic examples, Slatkin uncovers little-known Python quirks, intricacies, and idioms that powerfully impact code behavior and performance. You'll learn how to choose the most efficient and effective way to accomplish key tasks when multiple options exist, and how to write code that's easier to understand, maintain, and improve. Drawing on his deep understanding of Python's capabilities, Slatkin offers practical advice for each major area of development with both Python 3.x and Python 2.x. Coverage includes: * Algorithms * Objects * Concurrency * Collaboration * Built-in modules * Production techniques * And more Each section contains specific, actionable guidelines organized into items, each with carefully worded advice supported by detailed technical arguments and illuminating examples. Using Effective Python, you can systematically improve all the Python code you write: not by blindly following rules or mimicking incomprehensible idioms, but by gaining a deep understanding of the technical reasons why they make sense.