Reddit reviews Patterns of Enterprise Application Architecture
We found 46 Reddit comments about Patterns of Enterprise Application Architecture. Here are the top ones, ranked by their Reddit score.
Here's a list I compiled, the list books kind of hit a wide range. I don't really have any given list of talks I like. I'll just randomly google for videos by a speaker i like or subject I'm interested in.
Books:
Watch:
Podcasts:
Blogs:
News Letter:
Misc:
The resource seems very extensive such that it should suffice you plenty to be a good software engineer. I hope you don't get exhausted from it. I understand that some people can "hack" the technical interview process by memorizing a plethora of computer science and software engineering knowledge, but I hope you pay great attention to the important theoretical topics.
If you want a list of books to read over the summer to build a strong computer science and software engineering foundation, then I recommend to read the following:
The general theme of this list of books is to teach a hierarchy of abstract solutions, techniques, patterns, heuristics, and advice which can be applied to all fields in software engineering to solve a wide variety of problems. I believe a great software engineer should never be blocked by the availability of tools. Tools come and go, so I hope software engineers have strong problem solving skills, trained in computer science theory, to be the person who can create the next big tools to solve their problems. Nonetheless, a software engineer should not reinvent the wheel by recreating solutions to well-solved problems, but I think a great software engineer can be the person to invent the wheel when problems are not well-solved by the industry.
P.S. It's also a lot of fun being able to create the tools everyone uses; I had a lot of fun by implementing Promises and Futures for a programming language or writing my own implementation of Cassandra, a distributed database.
Actually i would suggest you to start learning OOP and maybe investigate the MVC design pattern, since those are both of subjects which average CodeIgniter user will be quite inexperienced in. While you might keep on "learning" frameworks, it is much more important to actually learn programming.
Here are few lecture that might help you with it:
This should give you some overview of the subject .. yeah, its a lot. But is suspect that you will prefer videos over books. Otherwise, some reading materials:
You will notice that a lot of materials are language-agnostic. That's because the theory, for class-based object oriented languages, is the same.
Also I would recommend for you to look into following concepts of object oriented programming:
[2]: http://www.youtube.com/watch?v=4F72VULWFvc
[3]: https://vimeo.com/21173483
[4]: http://qafoo.com/talks/11_02_phpuk_advanced_oo_patterns.pdf
[5]: http://www.youtube.com/watch?v=wEhu57pih5w
[6]: http://www.infoq.com/presentations/principles-agile-oo-design
[7]: http://www.youtube.com/watch?v=-FRm3VPhseI
[8]: http://www.youtube.com/watch?v=RlfLCWKxHJ0
[9]: https://vimeo.com/21145583
[10]: http://www.slideshare.net/stuartherbert/beyond-frameworks
[11]: https://vimeo.com/20610390
[12]: http://www.slideshare.net/sebastian_bergmann/agility-and-quality-php-uk-2011
[13]: https://vimeo.com/13439458
[14]: https://vimeo.com/12643301
[15]: http://www.amazon.com/PHP-Object-Oriented-Solutions-David-Powers/dp/1430210117
[16]: http://www.amazon.com/Design-Patterns-Explained-Perspective-Object-Oriented/dp/0201715945
You might want to look at Patterns of Enterprise Application Architecture by Martin Fowler. There are 3 full examples that you are looking for right now:
The examples are in Java but you probably won't have any difficulties understanding the code. He builds those from the ground up and finally compares them and says when to use what.
-----
Beyond that the abstraction endgame is to completely separate your persistence model from your domain model. If you have a user with an email address and other fields you don't want to have just one class that deals with loading the user row from a SQL database based on his email address, you want the latter part be isolated into its own class. (So that the user could in theory also be requested from an API or Memcached or a text file.)
class User { ... }
interface UserByEmailQuery {
public function findByEmail(string $email): User?;
}
class SqlUserByEmailQuery implements UserByEmailQuery { ... }
But it's sometimes simply not worth (economically) to go that far.
Books
Stuff to watch
Blogs
Other resources
Yet another long-winded and mostly useless BeautifulCode blog post that could've been avoided by suggesting that readers go buy Fowler's Refactoring (and read page 260 in this case, introduce Null Object) as well as the same Fowler's Patterns of Enterprise Application Architecture page 496 Special Case, A subclass that provides special behavior for particular cases.
Also, note that while the whole texts and explanations and examples and whatnot are not provided, you can find the refactorings and patterns of these books in The Refactoring Catalog and Catalog of Patterns, the respective websites of Refactoring and PoEAA
Pick up these books:
Just remember that the goal of a good architecture is to provide value, but maintain high quality of code that is easy to maintain and change. Separation of concerns , loose coupling, testability, maintainability and scalability are major points to look out for .
The book, Head First Design Patterns, is actually pretty good.
You could also read the book that started it all, Design Patterns: Elements of Reusable Object-Oriented Software. Although good, it is a dull read - I had to force myself to get through it.
Martin Fowler is also really good, in particular, I thoroughly enjoyed his book Patterns of Enterprise Architecture.
If you want more of an MS/.NET slant of things, you should also check out Dino Esposito. I really enjoyed his book Microsoft .NET: Architecting Applications for the Enterprise.
My recommendation would be to start with the Head First book first, as this will give you a good overview of the major design patterns.
You got some great feedback here--just wanted to give a +1 for PofEAA.
Just anecdotally, I'm a developer who never graduated from college. I had some luck in my favor--being in Silicon Valley in the late-90s "dot-com boom", and working for a spell at a non-software company that really needed some web applications built and improved. But luck only gets you so far anyway; I've been able to rise through the ranks to senior, lead and management roles primarily through hard work and, I think most importantly, really giving a shit about not just the code that I write, but the business and users I'm writing it for.
Now if I could only get somebody to pay me to learn C#...
http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
http://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683/ref=pd_bxgy_b_text_y
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
The following books would be good suggestions irrespective of the language you're developing in:
Patterns of Enterprise Application Architecture was certainly an eye-opener on first read-through, and remains a much-thumbed reference.
Domain-Driven Design is of a similar vein & quality.
Refactoring - another fantastic Martin Fowler book.
Also, take a note: patterns are only a small part of systems engineering applied to CS. Think REST and SOAP, think of how to better integrate two different applications together - not how to code their insides more efficiently. Start considering business logic and requirements - and you will find yourself whole new level of challenging architectural tasks.
Agreed. There are plenty of resources out there that will help you understand design patterns. If you're new to the concept, I would recommend Head First: Design Patterns, it might be based on Java, but the examples are simple to understand and can mostly apply to PHP as well. When you feel like you've grasped the basic concepts of design patterns, you can move on to more advanced texts, like Martin Fowler's Patterns of Enterprise Design - this is a great reference for a lot of the more common patterns. There is also Refactoring: Improving the Design of Existing Code. These are great investments that will help you with any project you work on, and will help you if you decide to use a framework like Zend which uses design patterns very heavily.
Couple must reads:
http://www.amazon.com/gp/aw/d/0321503627?pc_redir=1408680419&robot_redir=1
http://www.amazon.com/gp/aw/d/0321127420?pc_redir=1408765483&robot_redir=1
http://books.google.com/books/about/Domain_Driven_Design.html?id=hHBf4YxMnWMC
You are asking a good question.
Wouldn't doing a separate class for each of the use cases you described be repeating yourself?
I would read about DTO and see how it goes.
A good book about this is this.
Your foes are kids in their twenties with a degree which takes years to achieve, this will be tough! But I think your age and your willingness to learn will help you lot.
​
Other things to learn:
​
If there's one framework to look at, it would be spring: spring.io provides dozens of frameworks, for webservices, backends, websites, and so on, but mainly their core technology for dependency injection.
​
(edit: other important things)
Patterns of Enterprise Application Architecture
Thanks, I'm sure you will. It's just a question of getting that first success. Afterwards, it gets much easier, once you can point at a company and say "Their customers are using my code every day."
As for the interviews, I don't know, I'm honestly not the type to get nervous at interviews, either because I know my skill level is most likely too low and I take it as a learning experience, or because I know I can do it. I'd say that you should always write down all the interview questions you couldn't answer properly and afterwards google them extensively.
Besides, if you're from the US, you have a virtually unlimited pool of jobs to interview for. I live in a tiny European country that has 2 million people and probably somewhere in the range of 20 actual IT companies, so I had to be careful not to exhaust the pool too soon.
Funnily enough, right now, my CTO would kill for another even halfway competent nodejs developer with potential, but we literally can't find anyone.
Anyway, I'm nowhere near senior level, but I can already tell you that the architecture:language part is something your bootcamp got right. To that I would add a book my CTO gave me to read (I'm not finished yet myself, but it is a great book) - Patterns of Enterprise Architecture. Give it a look. I suspect, without ever having tried to implement a piece of architecture like that, it won't make much sense beyond theoretical, but I promise you, it's worth its weight in gold, once you start building something more complex and have to decide how to actually do it.
> Yes, the Native Query and access to Connection is always THE Hibernate's answer to all the lacking support of basic SQL features like Window Functions or being able to count aggregated results.
That's a very common misconception. Hibernate is not a replacement for SQL. It's an alternative to JDBC API that implements the Enterprise Patterns stated by Martin Flower in his book.
Thre are many alternatives to JPA or Hibernate. In fact, I'm also using jOOQ, and I like it a lot. I wrote about it. I'm using it in my training and workshops as well.
There are things you can do in jOOQ that you can't do with Hibernate, and there are also things you can do with Hibernate that you can't do with jOOQ.
Focus on other aspects. Reading and being able to talk architecture has gotten me a lot further than the “cracking the code”, leetCode type of stuff.
(None of these are affiliate links)
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Have you ever heard of the open/closed principle? Or the single responsibility principle? Or Liskov substitution principle? All three are being violated. It drastically reduces the maintainability and extensibility of your code. I can't swap serializers easily, i can't tweak or extend them without touching that huge class and it's definitely not the responsibility of that class to know how to serialize A, B, C, D, E and the whole alphabet.
I highly recommend some literature on the subject if you're curious about it, it would drastically improve your approach to software architecture:
https://www.amazon.com/dp/0132350882
https://www.amazon.com/dp/0201485672
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
http://cc2e.com/
https://www.amazon.com/dp/0321127420
Hey that is the million dollar question. But because software is not an engineering, actually there is no reference book on SW architecture. Certainly there are books talking about this, but usually covering only some aspects and without real application examples.
Notice that in iOS programming the system imposes a great part of the architecture, so these guys are usually less concerned. But in Android we have more freedom, and the API actually encourages really bad practices (thanks Google). Because of this we are all a bit lost. Nowadays layered architecture and MVP seems to be the most popular approach, but then again everybody produces a different implementation...
Specifically for Clean Architecture you should read its author, Robert C. Martin. AFAIK this is not covered in detail in his books. You can read this blog post and watch this video. Other designs usually coming up in conferences are the Onion Architecture and the Hexagonal Architecture. But make no mistake: there's no route map on how to implement any of those, and examples claiming to follow this or that approach are usually not written by the authors of the architecture.
For DDD there is a very good book by Scott Millet with actual examples. But this style is meant for large enterprise backend apps, and the author himself advices against using is in small apps. So I'd say it is overkill for Android, but of course you could reuse some concepts successfully.
Theres also Software Architecture in Practice 3rd, but having read the 2nd edition I can tell you this is just smoke.
Probably best book to date is Fowler's but this is more a patterns compilation than an architecture guide.
I recommend Martin Fowler's Patterns of Enterprise Application Architecture
Interesting!
Looks to me that you can "feel" what good code looks like but you're not able to rationalise it enough for you to write it on your own.
Couple of suggestions:
When you see elegant code, ask yourself: why is it elegant? Is it because is simple? Easy to understand? Try to recognise the desired attributes so you can try to reproduce on your code.
Try to write really short classes/methods that have only one responsibility. For more about this, search for Single Responsibility Principle.
How familiar are you with unit testing and TDD? It should help you a lot to write better designed code.
Some other resources:
Patterns of Enterprise Application Architecture sounds like a must read for you.
Umm this might become specific...
So Clean Architecture got me thinking a lot about code structure at a macro level, which is really important for development. It's a good beginning to understanding architecture but definitely not a definitive reference.
I would likely suggest any book that helps you understand your tech stack at a deeper level. If your goal is to say, be a lead developer, for example. Often the role of a lead is to support team members who are stuck.
So understanding the tech stack is important. For me, I got C# in a Nutshell. (I would suggest you getting the nutshell equivalent of your tech stack). It's important and it let's you understand what's happening under the hood.
Learn Algorithms in 24 Hours was a nice little primer on data structures and algorithms. While by no means a "revolutionary" book, it was useful in understanding what structures solved which problems.
So here's me answer:
If you're trying to get better at your stack: Get the Nutshell version of your language. Or buy a book on the framework your on.
If you're trying to just be a better computer scientist... I would learn Design Patterns (you noted this), then Architecture (Clean Architecture and then Patterns of Enterprise Application Architecture) then you're going to need to understand how to solve scaling problems. So Data Structures and Algorithms. This is hard because what book you want depends on your comfort with math.
For me, the biggest impact book, was design patterns. Then it was all the tech stack stuff that helped. Then finally, architecture books. The Martin Fowler architecture book was useful with design and thinking about how to handle saving data.
But it's really going to boil down to what you want to do with your career long term.
Well, some books can help:
These books on patterns tend to be good on teaching a lot of what you're asking. Largely because you've named some patterns in your question, but also because many patterns are about:
There are several ways to say what I just did in there. You're allowing X to vary independently from Y. This makes X a parameter of Y, which is yet another way to say it. You're separating what is likely to change often (X) from what doesn't need to be affected by that change (Y).
Some benefits from this is that a reason to change X, now, doesn't affect Y because X can be changed independently of Y. Another is that understanding X can be significantly done without looking at Y. This is a core guiding rule in the separation of concerns principle: the concern X is separated from the concern Y. Now, a lot of activities you want with X can be performed independently of Y.
You probably know all of this, so I'm sorry if this isn't much helpful. But just to finish, a classic example of this is a sorting function (the Y) and the comparison criteria (the X). Many people, in many projects, would like to have that a change in the comparison criteria not lead to a change in the sorting function. They're 2 separate concerns we'd like to deal with separately. Therefore, the comparison criteria, as commonly done today, is a parameter of sorting. In this case, the word "parameter" is being used both in the sense of a function parameter in the source code, but also in the more general sense of something being a parameter of something else, in which case something can be one of many, and may change over time.
Senior Level Software Engineer Reading List
Read This First
Fundamentals
Development Theory
Philosophy of Programming
Mentality
Software Engineering Skill Sets
Design
History
Specialist Skills
DevOps Reading List
First, ignore the code examples on the page. They are fairly bad. The reason you don't grok OOP is because of examples like these. What you want is a good solid book.
Patterns of Enterprise Application Architecture
PoEAA sounds imposing, but it's really good. I highly recommend it.
I also recently wrote up an article on Data Mapping that you might be interested in reading. If you have any questions, you can ask. Basically, for me, when I finally groked OOP, was when I was reading an article on observers, and how that pattern works, and I started to get it. I'm still learning. I'm only now getting over my need for getters and setters (You don't need them, they are bad, stop using them).
But yeah, the reason most OOP articles are bad is because most people using objects are merely using them as namespaces for functions and variables. If you have any questions, let me know.
When you get to a project larger than a small business or personal website it's less about the language and more about imposing a structure that makes sense backed by a data model that's thought out and performant.
I recommend these books:
http://www.amazon.com/High-Performance-MySQL-Optimization-Replication/dp/1449314287/ref=sr_1_1?ie=UTF8&qid=1425831227&sr=8-1&keywords=high+performance+mysql
http://www.amazon.com/gp/product/0321127420/ref=oh_aui_detailpage_o05_s00?ie=UTF8&psc=1
Upvote for Domain-Driven Design, it's a great book. Depending on the size of the system, Martin Fowler's PoEAA might also be helpful.
Also what dethswatch said: what's the audience & scope; i.e. what's in the previous document? If you're presenting three architectures you probably need enough detail that people can choose between them. That means knowing how well each will address the goals, some estimate on implementation effort (time & cost), limitations, future-proofing, etc.
Finally, IMHO, this really isn't computer science. You might have better luck asking in /r/programming/ or the new r/SWArchitecture/
Honestly I haven't read a "PHP book" in ages so I am a very bad source in critiquing. the majority of the one's I have come across are painfully outdated and some right out inaccurate. My suggestion to learn PHP programming better is try books that have to do with programming in general. Books on object orientation and patterns, like GOF http://en.wikipedia.org/wiki/Design_Patterns or PoEAA http://www.amazon.com/Enterprise-Application-Architecture-Addison-Wesley-Signature/dp/0321127420 are great for learning Object Oriented principals.
But those will help somewhat. What really helped me become a better PHP programmer is to study other languages, and then study their web frameworks, then take what you learned back to PHP. Find out why one aspect is pretty common in X language frameworks, but not PHP frameworks. How do other language frameworks solve the dependency issue, etc. Some languages I suggest learning are actually other ones that are pretty mainstream in web programming: Python for it's typing and how it compares to PHP. Ruby with how mixins relate to PHP traits. and Java is great as there are quite a bit of aspects that PHP stole off Java in it's OO design.
This here is my patterns bible:
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
As for .Net and SQL Server, it really depends on what you want to get into. Both have such a huge field of applications. In general MS Press is really good for books on their own stuff and written well enough that you can actually read through it.
Edit: But yeah, just realized that the book from Fowler also already is 14 years old. I need to update that as well :)
You can read books with code examples written in Java or C#, the syntax is very similar and the principles apply in the same way (PoEAA comes to mind).
I also recommend reading this book: Patterns of Enterprise Application Architecture
I’ll have a look, thanks!
Edit: this one?
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/ref=mp_s_a_1_2?keywords=martin+fowler&qid=1558200127&s=gateway&sr=8-2
Grady Booch
http://www.amazon.com/gp/aw/d/020189551X/ref=pd_aw_sbs_14_2?ie=UTF8&dpID=51-uo4HUPCL&dpSrc=sims&preST=_AC_UL100_SR100%2C100_&refRID=110KGH6M22KWAJHKWZ5F
Eric Evans
http://www.amazon.com/Domain-Driven-Design-Tackling--Software/dp/0321125215
Martin Fowler
http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
There are a ton of books, but i guess the main question is: what are you interested in? Concepts or examples? Because many strong conceptual books are using examples from java, c++ and other languages, very few of them use php as example. If you have the ability to comprehend other languages, then:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1322476598&sr=8-1 definetly a must read. Beware not to memorize it, it is more like a dictionary. It should be pretty easy to read, a little harder to comprehend and you need to work with the patterns presented in that book.
http://www.amazon.com/PHP-5-Objects-Patterns-Practice/dp/1590593804 - has already been mentioned, is related directly to the above mentioned one, so should be easier to grasp.
http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/ref=sr_1_1?ie=UTF8&qid=1322476712&sr=8-1 - one of the most amazing books i have read some time ago. Needs alot of time and good prior knowledge.
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_4?ie=UTF8&qid=1322476712&sr=8-4 - another interesting read, unfortunatelly i cannot give details because i haven't had the time to read it all.
When I said "I can see how maybe they could be useless to you.", that's because I instantly know what kind of programmer you were. You're a low level guy.
I have a copy of "Algorithms in a Nutshell" (http://www.amazon.com/Algorithms-Nutshell-In-OReilly/dp/059651624X) but I never finished it. My favorit programming book may be "Patterns of Enterprise Application Architecture" (http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420). Neither of these books are language specific, but I don't think they could be further apart in every way. Both are very valuable and I appreciate that they both exist.
There is a good number of reasons that you should maximize your use of the built-in PHP functions (http://webandphp.com/5reasonstomaximizeyouruseofPHP%E2%80%99sbuiltinfeatures). My book is an attempt to come up with a system that will help you learn all of the built-in PHP functions by giving a realistic use case that could be applied in your everyday work.
Being a PHP programmer, it is much more useful to know what functions PHP has for array sorting, than it is to know how to implement array sorting in PHP code.
PoEAA is fantastic and I recommend it to everyone. I reference it regularly.
However, those books don't come with step-by-step instructions on how to work with a legacy PHP codebase in order to modernize it. Modernizing Legacy Applications in PHP does.
I have this as well, but don't really have any remarks for you. That said, maybe you should look through some of the reviews for it on Amazon or the like. The reviews there seem pretty authentic.
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
Once you've mastered basic design patterns, this book will take you to a heightened state of consciousness.