Do modern programming languages, IDEs, and libraries make coding easy? Maybe, but coding is not design. Large-scale or expensive apps clearly require evaluation of design choices. Still, software design directly impacts code reuse and longevity even for small-scale apps with limited overhead. This text evaluates and contrasts common object-oriented designs. A given problem may have many solutions. A developer may employ different design techniques - composition, inheritance, dependency injection, delegation, etc. - to solve a particular problem. A skilled developer can determine the costs and benefits of different design responses, even amid competing concerns. A responsible developer documents design choices as a contract with the client, delineating external and internal responsibilities. To promote effective software design, this book examines contractual, object-oriented designs for immediate and sustained use as well as code reuse. The intent of identifying design variants is to recognize and manage conflicting goals such as short versus long-term utility, stability versus flexibility, and storage versus computation. Many examples are given to evaluate and contrast different solutions and to compare C# and C++ effects. No one has a crystal ball; however, deliberate design promotes software longevity. With the prominence of legacy OO code, a clear understanding of different object-oriented designs is essential. Design questions abound. Is code reuse better with inheritance or composition? Should composition rely on complete encapsulation? Design choices impact flexibility, efficiency, stability, longevity, and reuse, yet compilers do not enforce design and syntax does not necessarily illustrate design. Through deliberate design, or redesign when refactoring, developers construct sustainable, efficient code.

Do modern programming languages, IDEs, and libraries make coding easy? Maybe, but coding is not design. Large-scale or expensive apps clearly require evaluation of design choices. Still, software design directly impacts code reuse and longevity even for small-scale apps with limited overhead. This text evaluates and contrasts common object-oriented designs. A given problem may have many solutions. A developer may employ different design techniques - composition, inheritance, dependency injection, delegation, etc. - to solve a particular problem. A skilled developer can determine the costs and benefits of different design responses, even amid competing concerns. A responsible developer documents design choices as a contract with the client, delineating external and internal responsibilities. To promote effective software design, this book examines contractual, object-oriented designs for immediate and sustained use as well as code reuse. The intent of identifying design variants is to recognize and manage conflicting goals such as short versus long-term utility, stability versus flexibility, and storage versus computation. Many examples are given to evaluate and contrast different solutions and to compare C# and C++ effects. No one has a crystal ball; however, deliberate design promotes software longevity. With the prominence of legacy OO code, a clear understanding of different object-oriented designs is essential. Design questions abound. Is code reuse better with inheritance or composition? Should composition rely on complete encapsulation? Design choices impact flexibility, efficiency, stability, longevity, and reuse, yet compilers do not enforce design and syntax does not necessarily illustrate design. Through deliberate design, or redesign when refactoring, developers construct sustainable, efficient code.

Winner of a 2015 Alpha Sigma Nu Book Award, Software Essentials: Design and Construction explicitly defines and illustrates the basic elements of software design and construction, providing a solid understanding of control flow, abstract data types (ADTs), memory, type relationships, and dynamic behavior. This text evaluates the benefits and overhead of object-oriented design (OOD) and analyzes software design options. With a structured but hands-on approach, the book: Delineates malleable and stable characteristics of software design Explains how to evaluate the short- and long-term costs and benefits of design decisions Compares and contrasts design solutions, such as composition versus inheritance Includes supportive appendices and a glossary of over 200 common terms Covers key topics such as polymorphism, overloading, and more While extensive examples are given in C# and/or C++, often demonstrating alternative solutions, design-not syntax-remains the focal point of Software Essentials: Design and Construction. About the Cover: Although capacity may be a problem for a doghouse, other requirements are usually minimal. Unlike skyscrapers, doghouses are simple units. They do not require plumbing, electricity, fire alarms, elevators, or ventilation systems, and they do not need to be built to code or pass inspections. The range of complexity in software design is similar. Given available software tools and libraries-many of which are free-hobbyists can build small or short-lived computer apps. Yet, design for software longevity, security, and efficiency can be intricate-as is the design of large-scale systems. How can a software developer prepare to manage such complexity? By understanding the essential building blocks of software design and construction.

About the Cover:

Although capacity may be a problem for a doghouse, other requirements are usually minimal. Unlike skyscrapers, doghouses are simple units. They do not require plumbing, electricity, fire alarms, elevators, or ventilation systems, and they do not need to be built to code or pass inspections.

The range of complexity in software design is similar. Given available software tools and libraries many of which are free hobbyists can build small or short-lived computer apps. Yet, design for software longevity, security, and efficiency can be intricate as is the design of large-scale systems. How can a software developer prepare to manage such complexity? By understanding the essential building blocks of software design and construction.

About the Book:

Software Essentials: Design and Construction explicitly defines and illustrates the basic elements of software design and construction, providing a solid understanding of control flow, abstract data types (ADTs), memory, type relationships, and dynamic behavior. This text evaluates the benefits and overhead of object-oriented design (OOD) and analyzes software design options. With a structured but hands-on approach, the book:

• Delineates malleable and stable characteristics of software design
• Explains how to evaluate the short- and long-term costs and benefits of design decisions
• Compares and contrasts design solutions, such as composition versus inheritance
• Includes supportive appendices and a glossary of over 200 common terms
• Covers key topics such as polymorphism, overloading, and more

While extensive examples are given in C# and/or C++, often demonstrating alternative solutions, design not syntax remains the focal point of Software Essentials: Design and Construction. "