Gang Of Four Software Development
Gang Of Four Software Development Rating: 3,9/5 8623 votes
- What is Gang of Four (GOF)? In 1994, four authors Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides published a book titled Design Patterns - Elements of Reusable Object-Oriented Software which initiated the concept of Design Pattern in Software development. These authors are collectively known as Gang of Four (GOF). According to these.
- Mar 01, 2017 Design Patterns – Revisiting Gang of Four In software engineering, a design pattern is a repeatable solution to a commonly occurring problem in software design. Christopher Alexander, a civil engineer, is the one who came up with the idea of design patterns.
Gang Of Four Band
It has been influential to the field of software engineering and is regarded as an important source for object-oriented design theory and practice. More than 500,000 copies have been sold in English and in 13 other languages. The authors are often referred to as the Gang of Four (GoF). Gang of Four is not a design pattern, it is the colloquial name for the book 'Design Patterns: Elements of Reusable Object-Oriented Software' by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides (hence Gang of Four). Note that Gang of Four or GoF is used. Suspenseful background music. As you probably already realized, this book is one of the seminal books on patterns in software development. If you are a professional software developer, you must read this. It isolates 23 of the most common patterns and presents them in detail. This book is popularly known as Gang of Four book (Due to the 'gang of 4' great authors).
Gang Of Four Design Patterns
None of them. All of them.
It's a really unfortunate development that so many schools are emphasizing 'design patterns' as if they're some of the most important concepts in all of computer science, churning out students who have been trained to think of software development as a matter of repeatedly throwing chapters from the Gang of Four book at a problem until a working solution emerges.
To be clear: I am not criticizing the person who asked this question. I am criticizing the education systems that caused the question to seem relevant to, at the time I'm writing this answer, 23 people. (Going nuts over design patterns seems to be more common in some countries than in others, but it happens everywhere.)
Here's the deal with design patterns that is probably not obvious to someone who has learned them as if they are first principles in software development. They are observations, not rules. People noticed that programmers seemed to be approaching problems in similar ways in a bunch of different applications, and they decided that it would be pretty useful to be able to talk about those approaches using a common vocabulary so they wouldn't have to keep explaining what they were referring to. So they figured out general versions of these common practices and gave them names like 'Visitor' and 'Observer.'
There is value in studying common practices and common metaphors; in much the same way a good musician listens to a lot of other people's music and mentally picks it apart to learn why it's good, a skilled programmer should read a lot of other people's code and figure out what's good about it. If a bunch of smart people are solving a certain class of problem in a certain way, you should understand why they're doing it that way, not least because the solution might be one you hadn't thought of yourself.
But the important part is 'understand why.' The skill you need to cultivate to become a good developer and to be attractive to the kinds of companies in the question isn't plugging together objects from a library of canned formulas, but rather understanding the reasoning behind them deeply enough that, when faced with the same problem, you will arrive at the same solution on your own. And much more importantly, when faced with a similar but not identical problem, you will do something else rather than try to shoehorn the solution into an existing design pattern that's an awkward fit.
It's on that last point where the schools I criticize at the start of this answer really fail, and the result is gigabytes of horrific code (usually enterprise software) that's a teetering Jenga tower of generic implementations of popular design patterns stacked one on top of the other, resulting in software so complex and designs so obfuscated with unnecessary indirection that no developer can hold the entire logic in their head at once. There are plenty of jobs out there writing and maintaining that kind of pile-of-design-patterns software, but they don't tend to be at companies like Google.
It's a really unfortunate development that so many schools are emphasizing 'design patterns' as if they're some of the most important concepts in all of computer science, churning out students who have been trained to think of software development as a matter of repeatedly throwing chapters from the Gang of Four book at a problem until a working solution emerges.
To be clear: I am not criticizing the person who asked this question. I am criticizing the education systems that caused the question to seem relevant to, at the time I'm writing this answer, 23 people. (Going nuts over design patterns seems to be more common in some countries than in others, but it happens everywhere.)
Here's the deal with design patterns that is probably not obvious to someone who has learned them as if they are first principles in software development. They are observations, not rules. People noticed that programmers seemed to be approaching problems in similar ways in a bunch of different applications, and they decided that it would be pretty useful to be able to talk about those approaches using a common vocabulary so they wouldn't have to keep explaining what they were referring to. So they figured out general versions of these common practices and gave them names like 'Visitor' and 'Observer.'
There is value in studying common practices and common metaphors; in much the same way a good musician listens to a lot of other people's music and mentally picks it apart to learn why it's good, a skilled programmer should read a lot of other people's code and figure out what's good about it. If a bunch of smart people are solving a certain class of problem in a certain way, you should understand why they're doing it that way, not least because the solution might be one you hadn't thought of yourself.
But the important part is 'understand why.' The skill you need to cultivate to become a good developer and to be attractive to the kinds of companies in the question isn't plugging together objects from a library of canned formulas, but rather understanding the reasoning behind them deeply enough that, when faced with the same problem, you will arrive at the same solution on your own. And much more importantly, when faced with a similar but not identical problem, you will do something else rather than try to shoehorn the solution into an existing design pattern that's an awkward fit.
It's on that last point where the schools I criticize at the start of this answer really fail, and the result is gigabytes of horrific code (usually enterprise software) that's a teetering Jenga tower of generic implementations of popular design patterns stacked one on top of the other, resulting in software so complex and designs so obfuscated with unnecessary indirection that no developer can hold the entire logic in their head at once. There are plenty of jobs out there writing and maintaining that kind of pile-of-design-patterns software, but they don't tend to be at companies like Google.