Elemental Design Patterns, 1/e

Much like Linear Algebra introduces and develops a streamlined symbology for many-equation algebra, the author here introduces 'PIN', a method of encapsulating UML and collapsing the pattern-internals to focus on the -external- connections of the patterns. This elimination of visual complexity - while retaining the ability to 'zoom in' for the details - provides an environment better suited to actually exploring vast swaths of code in search of canonical patterns. Or antipatterns. The author proceeds to use his SPQR mechanistic pattern-seeking code in an attempt to identify individual 'Elemental Design Patterns'. That is - the indivisible core elements of the standard higher-level design patterns. In a fashion that is programming language agnostic. Although this work does not comprehensively explore the core canonical design patterns, it is still a solid introduction to the entire area that does not sink directly into the morass of extensive UML.

I nearly got lost in the theory parts of chapter 2 and 4, but wading through and taking the time to understand the ideas behind these "elemental" patterns was worthwhile upon reaching chapter 5, the pattern catalog, which constitutes the bulk of the book. The Pattern Instance Notation (PIN) diagram introduced in Chapter 3 was very well thought out, and although seemingly somewhat off topic, I'm glad it was included. It provides a hierarchical structure, which gives a way of viewing your system at different levels of granularity. I'm interested to see if it will catch on with software architects. The example code is in C++ and is well-formatted. Although the description of the book claims it will be part "example-rich cookbook", I'm not sure that I'd consider it to be at the cookbook level of practicality. In the end, I think this was an effort worthy of a read by architects and developers, and I think the PIN diagram system may gain popularity, if software aimed at authoring/viewing it easily became available.

I bought this book as a gift for my husband, who is a professional computer programmer and university instructor, and he loves it. He says that this book defines the vocabulary and concepts that programmers use to talk about their profession.

Great book and examples it is progressing with each chapter. I think it a good book for beginners and expart

This is a very intersting book. While the catalogue of patterns that form the result of the research aren't in themselves mind-blowing, the analytical methods that Jason McC. Smith used to arrive at the elemental design patterns, and the methods he uses to reconstruct well-known patterns based on these, are worthy of close study. This book is aimed toward software designers, architects and should be of utmost interest to creators of code analysis tools, since this was the impetus for the author's study in the first place. Far from being 'another design patterns' book, this seeks to present a foundation for *all possible* OO design patterns. An appendix demonstrates the mathematics that should prove this claim. To summarize the book's objective, Smith sought to derive the simplest possible language-agnostic patterns (e.g. 'extend method', 'instantiate class') from object-oriented principles as a way to use them as building blocks for recognizing larger constructs such as those presented in the well-known 'GoF' book, such as the 'Abstract Factory' or 'Visitor' patterns. The first half of the book is a friendly and entertaining guide through the author's research process in which he explains how the elemental patterns are combined. By supplementing UML with his own modelling innovations, he can deftly show how the elements interact in more complicated ways. The second half manages to not be tedious, despite it mostly being in a catalogue format similar to that used in the GoF's Design Patterns book. Even as someone who's currently more interested in functional-language software design than object-oriented, I found this to be a fascinating and enjoyable read and I'm confident that most would agree.

I bought this book, thinking it would provide a very basic overview of the common design patterns in software development. What I instead found was a very difficult read that more closely resembles a scientific dissection of the building blocks of said design patterns. While the author states in the preface that he assumes you will be familiar with design patterns at least in passing, I believe the reader will be absolutely lost without a somewhat higher level understanding of design patterns. I've read through the Gang of Four's Design Patterns book and still found that this material required several reads to finally sink in (not that the Gang of Four's book was all that different, to be honest). However, the content that is included is fascinating, if you have the patience to get through it. The Pattern Instance Notation (PIN) is a novel way to break down (or build up) design patterns from other patterns and might help Overall, Elemental Design Patterns is an interesting book and can provide an extra foundation for your software design, but I'd probably recommend it for software engineers and not software developers (if you can define the difference between the two groups of programmers, you'll probably enjoy this book).

Half way reading the book and I must say it has academic approach and it well describes the need of design patterns.

C'est un livre essentiel pour aborder les DP, intéressant et passionnant. Permet d'aborder plus facilement( c'est relatif) le livre DP du GoF.

This is an interesting book, well researched and well written. It's basic thesis is that the better known design patters, such as those explored by the 'Gang of Four' can be decomposed into more elementary patterns, and so on, until we have a number of elemental patterns which cannot be broken down any further. As part of this process, the author introduces a new type of diagram which he calls 'PIN' - Pattern Instance Notation. Since PIN is used extensively in the book to represent patterns it is essential to understand PIN fully. Unfortunately, there don't seem to be any tools that allow you to draw the PIN symbols, so it's difficult to learn it by using the system. This is something of a weakness in th book. That problem aside, the book is an interesting exposition of the fundamentals of patterns. However, the patterns Smith introduces are so very basic - Create Object, Recursion, and Inheritance, for instance - that I doubt that most application programmers will find its elementary pattern catalog particularly useful on a day to day basis. However, anyone involved in designing and programming refactoring browsers or the refactoring elements of an IDE will find find the contents of the book very useful. As a tool for automatically identifying incipient patterns in existing code I haven't seen anything that comes near it. Indeed, this was the genesis of the book - a project to automate the identification of certain patterns. Object oriented language designers may also find it useful for figuring out what they might need to build into their languages. The academic nature of the book is emphasized by substantial section on the formal logic involved using p-Calculus, on which I don't feel qualified to comment. Overall, I'd say that this may well be a useful book if you want to study patterns in more depth, or you are interested in automatic pattern recognition. As an ordinary programmer, though you won't find a great deal that's of instant use, since the patterns described are of a sufficiently low level that they are built into the language and idiom of most object orientated languages.