Ten Software Patterns Every Student Should Know
Description
Just as students of literature must know the basic canon of English works, so should students of software engineering know basic patterns of program development. Even with the advent of powerful AI tools for programming, it is important to understand the techniques and approaches to building efficient programs. This book picks out ten patterns that span several programming domains that represent key ideas that apply to breadth of software engineering tasks. The patterns are not algorithms but ways of approaching the construction of sophisticated software systems.
The book opens with one of the most ubiquitous software patterns that is often invisible to programmers: Hash tables. Yet building a truly scalable and efficient hash table that may even span multiple computers is not often taught in school and often cannot be obtained "off-the-shelf". Other patterns include using finite state machines to recognize basic patterns and to ensure programs don't miss critical use cases. Two patterns provide ways of reasoning about multi-threaded and multi-process programs and introducing a way of programming that works for both types of concurrent programming. The book closes with a call to design for failure: to anticipate that a complex system rarely works perfectly and that determining why something fails is almost as important as knowing why it works.
Michael Kilian holds a Ph.D. from Harvard University and been working in Software Engineering for nearly 50 years. This book grew from interviews with college students while working at Ab Initio and realizing that some basic ideas were missing from the curricula of even the brightest students.
More details
Person
After earning an MS in Computer Science from Rensselaer Polytechnic Institute, Michael Kilian went to work for the DEC Eastern Research Laboratory working on incremental compilation techniques for the Trellis object-oriented programming language. This effort produced one of the first compilation systems that treated code as objects, allowing small fragments to be modified and integrated into a complete program. On the strength of this work, Michael was accepted into the DEC Graduate Engineering Education Program, and earned a Ph.D. with his thesis Parallel Sets: An Object-Oriented Methodology for Massively Parallel Programming. Such was the beginning of nearly five decades in Software Engineering. His projects ranged from parallel object-oriented databases (using techniques from his thesis) to a distributed computation engine designed to robustly perform millions of complex transactions per second spread over commodity server platforms.
Throughout this career, several key technologies recurred: hash tables, finite state machines, and message-passing protocols to perform computations across multiple servers. While interviewing new graduates for engineering positions, it became apparent that some of these basic building blocks of complex systems were not being taught. Just as English Majors must be familiar with fundamental works in the English Language, Michael believed that certain software ideas were fundamental and should be understood regardless of whether a particular project required them
A laundry list of these topics was compiled and circulated to a number of colleagues and the ten patterns presented in this book is the result of those discussions. The list is not comprehensive. It also contains ideas that could be eliminated in a truly minimal list, but which have such elegance that a programmer should be exposed to them. The goal is to make a student familiar -- if not comfortable -- with programming models that have proved useful time and again.
Michael now consults for companies that need help in assessing software architectures to improve their own products, enter new businesses, or to qualify potential acquisitions. When not busy with his consulting, he enjoys woodworking, kayaking, and biking and continues to program.
Content
.- Chapter 1. Pattern 1: Hash Tables.
.- Chapter 2. Pattern 2: Finite State Machines.
.- Chapter 3 Pattern 3: Bloom Filters.
.- Chapter 4 Pattern 4: Network Programming.
.- Chapter 5 Pattern 5: Network Event Processing.
.- Chapter 6 Pattern 6: Digital Fingerprinting.
.- Chapter 7 Pattern 7: Concurrent Programming with Threads.
.- Chapter 8 Pattern 8: Concurrent Programming with Processes and Messages.
.- Chapter 9 Pattern 9: Memory Management.
.- Chapter 10 Pattern 10: Monitoring and Error Handling.