An introduction to the complete software development lifecycle from an agile perspective. This book brings together the most common practices in clean code, refactoring, design principles, testing, and configuration management, along with reflections on the creative and artistic nature of software and productivity techniques for developers. If you enjoyed The Programmer’s Black Book, this new work by Rafael Gómez Blanes offers essential insights for every professional programmer, with dozens of examples drawn from real-world C# and JavaScript projects. Foreword by Aurelio Gandarillas, an expert in software testing and quality.
If you would prefer a printed copy delivered by traditional mail, we can send it directly to Spain and the rest of Europe. Contact us to place your order!
Or read it using the Kindle app on your Android or Mac device.
Start reading an excerpt from The Practical Agile Programmer
Dirty, unreadable code; poor organization; misuse of tracking tools; excessively coupled code; a complete lack of documentation; glaring redundancies; disastrously organized code assets; no configuration management; hot fixes to production systems; “today I’ll code this because I like it more, and ignore what’s a priority for the project…”—and much more.
If this sounds familiar, you already know the outcome: frustrated programmers, an angry business spending more resources than it should, and solutions that sooner or later have to be thrown away (or completely rebuilt under a new version number…). Above all, there are programmers who, in my opinion, still need to make one more leap before they can be considered true professionals. I’m not talking about creating a hobby project on GitHub in your free time, but about working properly within a company, as part of a team whose goal is to deliver a software project with professional quality.
Why agile software? Because markets are changing faster and faster, time to market is shrinking, and at this point in the software industry we need to design applications that can evolve easily and cost less to maintain. The days of building excessively monolithic applications are long gone (although, much to my regret, I still see them in professional environments).
That is precisely what The Practical Agile Programmer aims to do: show you the fundamental techniques for making your application easy to change and maintain.
Over the years, I have been hired to investigate how different organizations work and the quality of the code they produce. In the process, I have gathered a great deal of material that I am now using to shape The Practical Agile Programmer. This has also given me the chance to revisit the essential references on agile development that every programmer should keep on their nightstand, and to explore those practices in greater depth.
The facts
- Programming can be relatively easy; there are plenty of books promising to teach a beginner PHP, Python, or JavaScript in 24 hours.
- Building solutions that truly use the object-oriented features of higher-level languages such as C# and Java—or even the latest versions of the languages mentioned above—is less straightforward and cannot be learned in a short time. In many cases, we barely use object orientation correctly.
- Developing an error-free application backed by tests adds another level of difficulty and calls for a completely different design approach.
- Developing software as part of a team requires other considerations: methodology, the use of specific collaboration tools, and following some kind of ALM (application lifecycle management) strategy.
- Finally, building a project that can accept changes, improvements, and new features for years without errors is a different matter altogether.
And yet, I am afraid that I often find myself in projects at serious companies that devote far more resources (€) to the first few points than to the last one.
The Practical Agile Programmer introduces the practices needed to ensure software quality in this broader sense: to make software maintainable and ready to evolve, and to ensure new features can be added with minimal effort. That way, developers spend most of their time… programming and delivering value—not fixing bugs, and certainly not putting up with frustrated business colleagues because the software they use fails or works poorly.
Nothing more and nothing less. It’s quite a challenge, but these are good practices that I have recently been keeping in mind again at Solid Stack, as we prepare to launch the licensed version of a product such as Picly.
Chapters in The Practical Agile Programmer
- Introduction
- Foreword
- A short story
- About the author
- What is software quality?
- Why software deteriorates
- Counterintuitive ideas
- A holistic view of software development
- Warning
- Clean code practices
- Meaningful names
- Classes
- Functions
- Comments
- Formatting
- Meaningful names
- Good design practices
- Introduction to refactoring
- Bad smells
- Refactoring techniques
- Agile software development
- S.O.L.I.D. principles
- Single Responsibility Principle (SRP)
- Open/Closed Principle (OCP)
- Liskov Substitution Principle
- Interface Segregation Principle (ISP)
- Dependency Inversion Principle (DIP)
- Dependency Injection (DI)
- Inversion of Control (IoC)
- Testing
- Testing techniques
- Unit testing
- Integration testing
- Performance testing
- Acceptance testing
- Configuration management
- Continuous integration
- Productivity techniques for developers
- To wrap up
- Bibliography
This new work gets straight to the point. It shows you the basic but essential techniques of clean code and refactoring, with countless examples and practical applications of indispensable principles such as SOLID.
The examples are written in C# and JavaScript. In each case, I have tried to choose the language that makes the example clearer.
The quality of our software project will improve by leaps and bounds simply by applying every concept in The Practical Agile Programmer.