Best Software Reuse Books
Enables the reader to understand the main benefits and challenges of software reuse when designing and building software.
1. Design Patterns: Elements of Reusable Object-Oriented Software
Author: by Erich Gamma
Published at: Addison-Wesley Professional; 1st edition (November 10, 1994)
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.
2. Kubernetes Patterns: Reusable Elements for Designing Cloud-Native Applications
Author: by Bilgin Ibryam
Published at: O'Reilly Media; 1st edition (May 7, 2019)
The way developers design, build, and run software has changed significantly with the evolution of microservices and containers. These modern architectures use new primitives that require a different set of practices than most developers, tech leads, and architects are accustomed to.
With this focused guide, Bilgin Ibryam and Roland Hu from Red Hat provide common reusable elements, patterns, principles, and practices for designing and implementing cloud-native applications on Kubernetes. Each pattern includes a description of the problem and a proposed solution with Kubernetes specifics.
Many patterns are also backed by concrete code examples. This book is ideal for developers already familiar with basic Kubernetes concepts who want to learn common cloud-native patterns. You’ll learn about the following pattern categories:Foundational patterns cover the core principles and practices for building container-based cloud-native applications.
Behavioral patterns explore finer-grained concepts for managing various types of container and platform interactions. Structural patterns help you organize containers within a pod, the atom of the Kubernetes platform. Configuration patterns provide insight into how application configurations can be handled in Kubernetes.
3. Reusable Firmware Development: A Practical Approach to APIs, HALs and Drivers
Author: by Jacob Beningo
Published at: Apress; 1st ed. edition (December 8, 2017)
Gain the knowledge and skills necessary to improve your embedded software and benefit from author Jacob Beningo’s more than 15 years developing reusable and portable software for resource-constrained microcontroller-based systems. You will explore APIs, HALs, and driver development among other topics to acquire a solid foundation for improving your own software.
Reusable Firmware Development: A Practical Approach to APIs, HALs and Drivers not only explains critical concepts, but also provides a plethora of examples, exercises, and case studies on how to use and implement the concepts. What You’ll LearnDevelop portable firmware using the C programming languageDiscover APIs and HALs, explore their differences, and see why they are important to developers of resource-constrained software Master microcontroller driver development concepts, strategies, and examplesWrite drivers that are reusable across multiple MCU families and vendorsImprove the way software documentedDesign APIs and HALs for microcontroller-based systemsWho This Book Is ForThose with some prior experience with embedded programming.
4. Mastering Object-Oriented Python: Build powerful applications with reusable code using OOP design patterns and Python 3.7, 2nd Edition
Author: by Steven F. Lott
Published at: Packt Publishing (June 14, 2019)
Gain comprehensive insights into programming practices, and code portability and reuse to build flexible and maintainable apps using object-oriented principles Key Features Extend core OOP techniques to increase integration of classes created with Python Explore various Python libraries for handling persistence and object serialization Learn alternative approaches for solving programming problems, with different attributes to address your problem domain Book Description Object-oriented programming (OOP) is a relatively complex discipline to master, and it can be difficult to see how general principles apply to each language’s unique features.
With the help of the latest edition of Mastering Objected-Oriented Python, you’ll be shown how to effectively implement OOP in Python, and even explore Python 3.X. Complete with practical examples, the book guides you through the advanced concepts of OOP in Python, and demonstrates how you can apply them to solve complex problems in OOP.
5. Hands-On Design Patterns with C# and .NET Core: Write clean and maintainable code by using reusable solutions to common software design problems
Author: by Gaurav Aroraa
Published at: Packt Publishing (July 5, 2019)
Apply design patterns to solve problems in software architecture and programming using C# 7.X and . NET Core 2 Key Features Enhance your programming skills by implementing efficient design patterns for C# and . NET Explore design patterns for functional and reactive programming to build robust and scalable applications Discover how to work effectively with microservice and serverless architectures Book Description Design patterns are essentially reusable solutions to common programming problems.
When used correctly, they meet crucial software requirements with ease and reduce costs. This book will uncover effective ways to use design patterns and demonstrate their implementation with executable code specific to both C# and .NET Core. Hands-On Design Patterns with C# and .
NET Core begins with an overview of object-oriented programming (OOP) and SOLID principles. It provides an in-depth explanation of the Gang of Four (GoF) design patterns such as creational, structural, and behavioral. The book then takes you through functional, reactive, and concurrent patterns, helping you write better code with streams, threads, and coroutines.
6. Design Patterns for High-Quality Automated Tests: High-Quality Test Attributes and Best Practices
Author: by Anton Angelov
Published at: Independently published (March 6, 2020)
About This BookAchieving high-quality test automation that brings value- you need to understand core programming concepts such as SOLID and the usage of design patterns. After you master them, the usual career transition is into more architecture roles, such as choosing the best possible approaches for solving particular test automation challenges.
You will get an access to more than 20000+ lines of real-world code examples. Who This Book Is ForThe book is NOT a getting started guide! If you don’t have any prior programming experience in writing automated tests through WebDriver, I suggest you to first start with some book about basic programming and basic WebDriver usage.
I believe it might be invaluable for the readers that have a couple of years of experience and whose job is to create/maintain test automation frameworks, or to write high-quality reliable automated tests. The book is written in C#.
However, I think that you can use the approaches and practices in every OOP language. If you have a Java background (or similar), you will get everything you need, don’t worry. Even if you don’t get all the concepts from the first read, try to use and incorporate some of them, later you can return and reread them.
7. Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (paperback) (Addison-Wesley Microsoft Technology Series)
Author: by Krzysztof Cwalina
Published at: Addison-Wesley Professional; 3rd edition (June 18, 2020)
Master Today’s Best Practices for Building Reusable . NET Frameworks, Libraries, and Components . NET Core [contains] advances important to cloud application developers: performance, resource utilization, container support, and others. This third edition of Framework Design Guidelines adds guidelines related to changes that the .
NET team adopted during transition from the world of client-server application to the world of the Cloud. From the Foreword by Scott Guthrie Framework Design Guidelines has long been the definitive guide to best practices for developing components and component libraries in Microsoft .NET.
Now, this third edition has been fully revised to reflect game-changing API design innovations introduced by Microsoft through eight recent updates to C#, eleven updates to . NET Framework, and the emergence and evolution of .NET Core.Three leading . NET architects share the same guidance Microsoft teams are using to evolve .
NET, so you can design well-performing components that feel like natural extensions to the platform. Building on the book’s proven explanatory style, the authors and expert annotators offer insider guidance on new . NET and C# concepts, including major advances in asynchronous programming and lightweight memory access.
8. Analysis Patterns: Reusable Object Models
Author: by Martin Fowler
Published at: Addison-Wesley Professional; 1st edition (October 1, 1996)
Martin Fowler is a consultant specializing in object-oriented analysis and design. This book presents and discusses a number of object models derived from various problem domains. All patterns and models presented have been derived from the author’s own consulting work and are based on real business cases.
9. C Interfaces and Implementations: Techniques for Creating Reusable Software
Author: by David Hanson
Published at: Addison-Wesley Professional; 1st edition (August 20, 1996)
Creating reusable software modules; they are the building blocks of large, reliable applications. Unlike some modern object-oriented languages, C provides little linguistic support or motivation for creating reusable application programming interfaces (APIs). While most C programmers use APIs and the libraries that implement them in almost every application they write, relatively few programmers create and disseminate new, widely applicable APIs.
C Interfaces and Implementations shows how to create reusable APIs using interface-based design, a language-independent methodology that separates interfaces from their implementations. This methodology is explained by example. The author describes in detail 24 interfaces and their implementations, providing the reader with a thorough understanding of this design approach.
Features of C Interfaces and Implementations: * Concise interface descriptions that comprise a reference manual for programmers interested in using the interfaces. A guided tour of the code that implements each chapters interface tp help those modifying or extending an interface or designing related interfaces.
10. MonoGame Mastery: Build a Multi-Platform 2D Game and Reusable Game Engine
Author: by Jarred Capellman
Published at: Apress; 1st ed. edition (November 10, 2020)
Intermediate user level
11. Design Patterns in .NET: Reusable Approaches in C# and F# for Object-Oriented Software Design
Author: by Dmitri Nesteruk
Published at: Apress; 1st ed. edition (May 13, 2019)
Implement design patterns in . NET using the latest versions of the C# and F# languages. This book provides a comprehensive overview of the field of design patterns as they are used in today’s developer toolbox. Using the C# programming language, Design Patterns in .
NET explores the classic design pattern implementation and discusses the applicability and relevance of specific language features for the purpose of implementing patterns. You will learn by example, reviewing scenarios where patterns are applicable. MVP and patterns expert Dmitri Nesteruk demonstrates possible implementations of patterns, discusses alternatives and pattern inter-relationships, and illustrates the way that a dedicated refactoring tool (ReSharper) can be used to implement design patterns with ease.
What You’ll LearnKnow the latest pattern implementations available in C# and F#Refer to researched and proven variations of patternsStudy complete, self-contained examples including many that cover advanced scenariosUse the latest implementations of C# and Visual Studio/ReSharperWho This Book Is ForDevelopers who have some experience in the C# language and want to expand their comprehension of the art of programming by leveraging design approaches to solving modern problems
12. Framework Design Guidelines: Conventions, Idioms, and Patterns for Reuseable .NET Libraries
Author: by Krzysztof Cwalina
Published at: Addison-Wesley Professional; 2nd edition (October 31, 2008)
Framework Design Guidelines, Second Edition, teaches developers the best practices for designing reusable libraries for the Microsoft .NET Framework. Expanded and updated for .NET 3. 5, this new edition focuses on the design issues that directly affect the programmability of a class library, specifically its publicly accessible APIs.
This book can improve the work of any . NET developer producing code that other developers will use. It includes copious annotations to the guidelines by thirty-five prominent architects and practitioners of the . NET Framework, providing a lively discussion of the reasons for the guidelines as well as examples of when to break those guidelines.
Microsoft architects Krzysztof Cwalina and Brad Abrams teach framework design from the top down. From their significant combined experience and deep insight, you will learn The general philosophy and fundamental principles of framework design Naming guidelines for the various parts of a framework Guidelines for the design and extending of types and members of types Issues affectingand guidelines for ensuringextensibility How (and how not) to design exceptions Guidelines forand examples ofcommon framework design patterns Guidelines in this book are presented in four major forms: Do, Consider, Avoid, and Do not.
13. Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML, 2nd Edition, Volume 1
Author: by Mark Grand
Published at: Wiley; 2nd edition (September 17, 2002)
“This is the best book on patterns since the Gang of Four’s Design Patterns. The book manages to be a resource for three of the most important trends in professional programming: Patterns, Java, and UML.” Larry O’Brien, Founding Editor, Software Development Magazine Since the release of Design Patterns in 1994, patterns have become one of the most important new technologies contributing to software design and development.
In this volume Mark Grand presents 41 design patterns that help you create more elegant and reusable designs. He revisits the 23 “Gang of Four” design patterns from the perspective of a Java programmer and introduces many new patterns specifically for Java.
Each pattern comes with the complete Java source code and is diagrammed using UML. Patterns in Java, Volume 1 gives you: 11 Behavioral Patterns, 9 Structural Patterns, 7 Concurrency Patterns, 6 Creational Patterns, 5 Fundamental Design Patterns, and 3 Partitioning Patterns Real-world case studies that illustrate when and how to use the patterns Introduction to UML with examples that demonstrate how to express patterns using UML The CD-ROM contains: Java source code for the 41 design patterns Trial versions of Together/J Whiteboard Edition from Object International (www.Togetherj.
14. C++ Network Programming, Volume 2: Systematic Reuse with ACE and Frameworks
Author: by Debbie Lafferty
Published at: Addison-Wesley Professional; 1st edition (October 29, 2002)
Writing high-quality networked applications is difficult – it’s expensive, complicated, and error-prone. In order to be successful, software for networked applications must be affordable, extensible, flexible, portable, predictable, efficient, reliable, and scalable. This book picks up where volume one left off, and guides C++ programmers through using the ADAPTIVE Communication Environment (ACE), the most complete toolkit available for networked programming.
The first volume focused on problem solving and understanding ACE. This second volume focuses on reuse and frameworks. Both volumes are modeled on Richard Stevens’ classic UNIX Network Programming. ACE was invented by Doug Schmidt, and is completely open-source. Steve Huston founded a company which provides support for ACE users, and is at the forefront of the growing ACE community.
15. Design Patterns in Modern C++: Reusable Approaches for Object-Oriented Software Design
Author: by Dmitri Nesteruk
Published at: Apress; 1st ed. edition (April 19, 2018)
Apply modern C++17 to the implementations of classic design patterns. As well as covering traditional design patterns, this book fleshes out new patterns and approaches that will be useful to C++ developers. The author presents concepts as a fun investigation of how problems can be solved in different ways, along the way using varying degrees of technical sophistication and explaining different sorts of trade-offs.
Design Patterns in Modern C++ also provides a technology demo for modern C++, showcasing how some of its latest features (e.G., coroutines) make difficult problems a lot easier to solve. The examples in this book are all suitable for putting into production, with only a few simplifications made in order to aid readability.
What You Will LearnApply design patterns to modern C++ programmingUse creational patterns of builder, factories, prototype and singletonImplement structural patterns such as adapter, bridge, decorator, facade and moreWork with the behavioral patterns such as chain of responsibility, command, iterator, mediator and moreApply functional design patterns such as Monad and moreWho This Book Is ForThose with at least some prior programming experience, especially in C++.