More often than not, computer science (CS) graduates feel overwhelmed and quite puzzled when being exposed to enterprise-level software development techniques at the start of their professional careers. Inherently, universities--through their curricula--provide good theoretical foundations to programming and software engineering methodologies. However, they do so using lecturing methods that skim off the top of related topics and with lack of proper exposure to well-established industry tools and standards. This book targets CS students and aims to provide them with a better understanding of the practical side of software development, an asset that will be significantly valuable when joining the professional workforce. It’s a short and easy-to-read handbook that provides best practices for tools and techniques that are considered as the basis for development and maintenance of large-scale software solutions. The book is divided into three logical parts and one part with appendices.

The first part (chapters 1 to 4) introduces the reader to core concepts of enterprise-level software engineering such as requirements analysis, design patterns, and development methodologies. In chapter 1, the author explains how enterprise software differs from software developed both in academia and in small enterprises or startups. Chapter 2 drills down to the role of business software requirements and more specifically how to write and interpret good business requirements documents (BRDs), both from a functional as well as a technical perspective. Chapter 3 engages in the all-important topic of design patterns and system architecture by giving an extensive overview of mainstream design patterns used in today’s enterprise environments, such as observer (behavioral), facade (structural), and singleton (creational). Having good knowledge of such fundamental design patterns, developers are able to write better and more constructive code. In addition, it strengthens their skills in comprehending, using, and refactoring other people’s code. Furthermore, this chapter makes particular reference to two enterprise patterns, model-view controller (MVC) and dependency injection (DI), both predominately utilized in distributed software solutions. Toward the end, this chapter discusses how hardware architecture patterns affect software design and implementation. Chapter 4 deals with development methodologies that drive the software development life cycle (SDLC). In that respect, two different methodologies are discussed: the well-established waterfall model and its more recent counterpart agile. Different aspects of each methodology are presented, their key characteristics are compared, and their applicability to different scenarios is discussed. Tools valuable to distributed teams, such as code reviews and bug tracking, are briefly presented.

The second part (chapters 5 to 7) revolves around applied concepts that are used during SDLC. Initially, chapter 5 reviews version control systems, a valuable asset in any distributed team setting. Subversion (SVN) is used for demonstration purposes, and core features such as commits, checkouts, conflict resolution, branching, and tagging are discussed. Distributed version control (Git) is briefly mentioned, highlighting its core differences to centralized version control systems. Chapter 6 visits unit testing and test-driven development (TDD), with which code behavior and reliability can be evaluated repeatedly. JUnit (Java) and NUnit (.NET) are utilized as exemplary technologies for showcasing unit testing under different programming languages. Likewise, chapter 7 talks about improving the design, reducing duplication, and making code easier to maintain using refactoring techniques. Using TDD, developers can assert that code cleanup will not interfere with the reliability of code output.

The third part (chapters 8 to 10) touches upon three important topics: code debugging, build automation, and data-oriented programming. Chapter 8 discusses code debugging and related concepts in identifying problematic code and mitigating its effects on global system behavior. Any CS student should be able to follow this chapter adequately and refresh his or her knowledge in debugging. Chapter 9 introduces build and continuous integration tools for large and complex software projects. Automation tools (Ant, Maven) are examined for centralizing the build, management, and reporting of Java-based software components and their dependencies. Continuous integration (CI) methods are shortly outlined next, and their features along with their benefits are explained. The final segment of this section, chapter 10, gives a short but precise crash course on two virtues every information technology (IT) professional should possess: proficiency in structured query language (SQL) and data frameworks. It aims to enhance understanding on how a developer can interact with a relational database system in order to retrieve information items. Basic SQL statements are presented and data framework programming such as JDBC and ADO.NET are discussed.

Overall, this book flows very well and touches on a number of important aspects concerning enterprise software development techniques. Importantly, to assist the reader in grasping various concepts, all chapters are accompanied by easy-to-read-and-understand code snippets. If you are a CS student or graduate and you want to quickly get up to speed with industry standard practices, this book will serve as a worthy starting point in that journey.