Absolutely incredible service. Not only were they on hand to solve issues i had with my website he gave further advice on what to have in place. He is so knowledgeable that they make wanting to call out bigger companies because the bigger companies do not offer the knowledge and support that Ben provides. I look forward to further business relations and dealing with Ben. Thank you so much more than 5 stars.
I would like to appreciate Ben for providing his services , he is very professional guy who knows his work and very co operative and helps you in achieving your goal , i would definitely recommend him.
I shared some problems I had encountered with my WordPress website onto a Facebook group for people needing help with their WordPress sites. Ben came to my rescue! Ben has been extremely selfless and a life safer with helping me sort problems I had with the website. Not only did Ben fix the problems, in such a short amount of time but Ben went above and beyond to give me suggestions, run through my website himself and picked up on improvements that could be made, risks and I noticed Ben has a very creative mindset, he thinks of user interaction and ease of use with customers using your website and suggested things I hadn’t even thought of to change! Ben also has great knowledge in the security of websites, so he can envision how a hacker would be able to take advantage of the website and what they would use, he explains all of this in a very easy way to understand! Ben took so much of his time to explain this to me, I went from being quite scared to launch the website to now understanding how it works. Thank you again Ben for all of your help and I would honestly recommend you to anyone I haven’t come across anyone so willingly eager to help and doesn’t make you feel silly for mistakes or not understanding the world of web designing. 10 stars if I could.
I didn’t think i would see results, but thank you for making my business Great again!
The book starts a bit silly. If I’m reading a book about object oriented PHP development, is because I WANT to do OOP with PHP, you don’t have to sell it to me or tell me that since previous versions there was some hideous object orientation-like structure. I fear this comes to “fix” the issue that a most of the open source PHP projects I’ve seen are not object oriented (or were not when I looked at them), so the book tries to teach how to do things better in OOP.
Apart from that, it starts not teaching you the basics of PHP, but entering directly into objects in PHP5, which I appreciate. It goes step by step explaining everything, and giving good advices of bad practices to avoid.
There are a lot of notes of how to “fix” the code for PHP4, not bad, but a bit annoying. Given the poor object orientation of all previous versions, the book should stick to PHP5 only. The book explains all basic concepts of OOP (including advices and good practices), UML diagrams, going on to specific design pattern implementations in Part 3 of the book.
This has been for me personally the “gold” part of the book, specific PHP 5 implementations of DP allowed me to see true object oriented source codes. The patterns come from three widely known books, and are very well explained. We can find from the typical Singleton or Factory, to some other advanced ones like the Strategy or the Observer.
The code samples are quite good, giving you direct examples of how to implement a Factory design pattern or playing with classes and inheritance to show exactly how they work. There is a lot of theory and good practices too. Much better than the usual hello world and simple ones, this codes can be really of help in real word scenarios.
Avoiding reinventing the wheel, whenever necessary the book mentions the SPL (Standard PHP Library) for already available pattern tools and objects (like the Observer or the Iterator). Chapter 11 goes on some Gang of Four patterns (the classics), but chapter 12 talks about enterprise patterns, and chapter 13 database patterns.
One of the big examples is actually how to build a full MVC engine, with a frontend controller, an application controller for the logic, views, templates (including the Template pattern by Fowler). After the MVC and presentation patterns, another bunch of Business Logic Layer patterns (like the Domain Models), and then goes into Database patterns, like the Data Access Layer, Identity Map.
When approaching serialisation, gives good advices on how to do it. And if any kind of code hack or “non-perfect technique” is performed, we are advised of it very clearly. I wish other books were so careful to try to teach only good things. After a bit more than 300 pages, the book switches to non-coding advices, tips and basic knowledge, like source code control (but using CVS, which is quite outdated!!), PEAR, testing with PHPUnit, automated builds.
This part for me felt a bit like filling up pages of the book. If I want generic advices I will search for them, I was searching for design patterns applied to PHP and as much as general advices, not more than 160 pages of non-patterns stuff. Being a .NET developer since years, at first looks strange to me to be teached once and again that I should use classes and structure accordingly the code.
While not yet perfect, object orientation in PHP5 looks useful enough to be able to do really good architectures for web applications, it just lacks more restrictions to avoid an immense amount of errors that still can happen if you’re not a skilled PHP developer (things like dynamic properties creation, untyped parameters or dynamic class instantiation should be at least redone in a more restrictive syntax).
Also, I liked the author’s point of view, not telling you to always implement design patterns the same way, but understand what they try to solve, and extract what you need for your projects. I really wish other books (whenever about PHP or any other language) had so good and real-life practical examples as this one.
This book is a must-read for PHP developers that want to take out the common thinking of “you can’t do clean code with PHP” (which sadly occurs too often). Even when it should be only 300 pages, is worth it (but is also why I’m giving it 3 stars out of 5).
As hinted in the title, this near 500 page tome is split into three parts: objects, patterns and [best] practice. The section on objects covers the basics and then the advanced features of object oriented facilities in PHP and tools such as namespaces, autoloading and the reflection classes along with design basics, class scope, encapsulation, polymorphism and some UML.
The patterns section is obviously inspired by “The Gang of Four” (Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides) and covers what design patterns are, enterprise patterns, database patterns and also the basic patterns such as the factory, facade, decorator and composite patterns along with a few more. This section is far from comprehensive, but is a good start. (If Patterns do interest you, and they should, have a look at patternsforphp.com)
The last section, focuses on PEAR (including writing your own packages and setting up your own PEAR channel), phpDocumentor, unit testing with phpUnit, version control with CVS (which struck me as a bit odd – I had expected subversion to be covered either instead of or along with CVS) and setting up automated builds with phing.
While being an easy read, this is a well written, serious book and is aimed squarely at enterprise-level developers and software engineers who make their living through the development and architecture of solutions developed in PHP. Any PHP developer wishing to improve his skills should get a copy.
This book is an excellent bible on how to write PHP software well. It explains all the things you thought you knew, but didn’t. This is not a beginners book – the first (and simplest) chapter begins with a discussion on OOP throughout recent versions of PHP! For someone who thinks they are pretty good already, this is a great sidekick.
Matt Zandstra has chosen a very good approach for this book. He first introduces readers to basic and advanced OOP features which are available PHP v5 and above. It’s an interesting read even if you are already familiar with the topic.
He then slowly starts introducing individual patterns and approaches which form the core focus of the book. Patterns are introduced in a very logical order – both in terms of complexity and in relationships which are formed between individual patterns.
Most patterns in the book are based on one sample application and they revolve around solving common challenges which one would face during its development. This approach supports a gradual and easy to comprehend flow of information which are presented to the reader.
The remaining “practice” part of the book is then focused on tools and solutions which are commonly used during a web application development life cycle. Just to name a few – source code management, unit testing and automated build tools – these are all a must for anyone working on larger projects.
I agree with the author that this is a topic rarely covered in programming books, and I really enjoyed this section – it’s a very good and practical wrap-up of the topic. I can honestly recommend this book to any intermediate or advanced PHP developer.
The topics alone are very interesting, and the author shares them in a good, consistent and practical manner. I consider it to be the best book on PHP which I have read so far.
This book is not for the beginner but for those interested in learning or advancing their knowledge of Object Oriented Programming, Design Patterns and general good practice.
An excellent book, not short on examples, very verbose with techniques, i’m confident even the most advanced PHP developer could learn something (if only just a few more design patterns).
Highly recommended, well written, well researched and even contains hints as to the path PHP 6 will take, so it won’t date too quickly. Rating: 5/5
There are very few books on this topic and so it’s not hard for it to be one of the better ones – which it probably is. I liked the way it started but it soon departs from offering knowledge in “bite-sized” chunks and assumes you will want to learn by following examples that are unnecessarily lengthy or complex.
Like a lot of experts Matt seems to find difficulty in putting himself in the shoes of his (less expert) readers. Inch by inch lifes a synch. A mile at a time life’s a swine. I have to say that it wasn’t long before I reverted to looking for tutorials and examples on the web which, whilst few and far between, were nonetheless more helpful.
Great book, I recommend it both to those who need to start and to those who have to take back certain concepts after some time: it is very complete.
I bought this book in paperback format a year ago but I find it cumbersome to combine with my laptop, so I bought the Kindle version as well. Now I have my Kindle reader program on one half of the screen and PhpStorm on the other half and it works great. And I can read the book on my phone as well. Only con with the Kindle format is the price. It cost allmost as much as the paperback version.
Difficult to read without book holder, kindle version would be better. Examples could be longer. Some demo app to build while progressing the book would make reading much more interesting. Overall: solid book.
I have the book that covers the 7.0 version, and today I got the new edition that covers 8.0. The good thing about reading this book a second time is that with five years of experience in the industry and have worked on multiple projects, some legacy and others with modern architecture.
Now I appreciate the clarity and the wisdom that this author has distilled in these pages. This is a book for mid to advance PHP developers; I wouldn’t recommend this to a person trying to learn to code; OOP is to much of a complex subject to grasp when you are starting.
But if you have worked with objects in the past, you are a library maintainer, or wants to gain deeper insight into best practices and go to your next level as a software engineer; then this book is a must to add to your collection. Definitely worth every penny.
I wouldn’t hope to learn PHP OOP from this book, it’s rather for people who know OOP already. The book is in 3 parts and the most useful one (for me) – patterns – is translating the most popular patters (taken mostly from Java and the “gang of four” ideas) to PHP.
This subject is really advanced and the patterns can serve as a good starting point for different programming challenges. Not an easy book, but very good and professional approach. The author is doing much to make it easier to understand.
No doubt that Robert C. Martin is one of the most influential author and software development theorist of our times. The already standard SOLID principles had been with us for decades, serving software discipline with full success. The Clean Series is a set of books full of advises, thoughts, ideas, rationales and principles with the same impact.
If you know his videos and lectures, probably this book will see familiar and many of the topics discussed repetitive. But the book has the value to reunite and review his software development discipline philosophy in a concise and complete harmonious set of essays. The main idea is to avoid dependency applying the Dependency Rule at all levels, classes and components.
The Dependency Inversion graph, where high-level functions calling middle-level functions through an interface that the middle-interface implements, is a medular software construction that should be applied as an obsessive pattern. It guarantees independence, reusable, clean architecture.
I started this book with high expectations as Clean Code was a wonderful book. Will Clear Architecture be like that? Unfortunately, no. This book is still worth reading for people interested in software design, I don’t believe the impact and role of this book will be similar to the earlier Clean Code book. There is not that much news and most of the book seems to talk about the architecture of relatively small systems.
The second part introduces three programming paradigms. I was surprised to see this in a book about architecture didn’t mind as I do enjoy reading about programming paradigms. The author claims that there are three and there will never be more, which came a bit as a surprise as I was aware of more than 3 paradigms (and so is the wikipedia page on programming paradigms).
The three paradigms covered in this book is structured, object-oriented, and functional. It describes these three from an interesting perspective, which is that each one adds a constraint. The third part is a summary of the SOLID principles which Robert Martin has covered many times in his earlier work.
They are described a little bit differently as before. I am not a fan of the way the Single-Responsibility Principle is explained in this book — “a module should be responsible for one, and only one, actor” and felt the example a bit strange. But all in all, the SOLID principles are useful principles to have in your toolbox.
Appendix A is still 50 pages of additional writing where the author summarizes his experience in working on different systems and what he has learned from which systems. Clean architecture was an interesting read.
I liked the clean architecture pattern that the author presents and his explanation of it. That makes the book worth reading. Other parts I likes less and often felt the description was a bit over simplified
Great reference material for Clean Architecture. If you’ve watched his CleanCoders series, then it’s a lot of the same material. That’s not a bad thing.
The amazing thing about this book is that the author converts what you can find in another books looking “complex concepts” in really “easy concepts”. Is amazing how the author simplify the problems and display examples to make clear everything. I was really impressed with the insight of this author.