|All reviews||A Year With Symfony||Latest reviews||Best sellers ranking|
A Year With Symfony
September 4, 2013
Week: 4 All time: 388
joseluislaso.es“A Year With Symfony” it is merely a way of saying, as the author commented in the introduction of this book.
With more than six years dealing with Symfony, the author proposes us a deep dive into the internals of this framework in order to learn about PHP and how to take the best our of it.
The author takes the readers by the hand, along the internals of Symfony with very well explained code.
Definitively, it is not a book for a Symfony newcomers, but it is a good starting point for developers that do not know in depth the internals of the framework.
It is also for developers of other PHP frameworks, or even other frameworks for different languages, and why not, PHP developers with great skills in OOP that want to learn quickly the framework from the scratch.
The structure of the book follows a logic distribution starting from the journey of the HTTP request to the response, followed by patterns like dependency injection and much more: project structure, configuration conventions, security, and being a Symfony developer.
All the chapters are presented with an introduction of the chapter subject, a lot of code and comments about it.
One important point from the pedagogic point of view is that the code is simplified in order to explain step by step, sticking only the current subject. The author introduces the rest of the code in a magical way that allows the reader to understand the subject with a minimal effort.
Lets take a look now more in detail the contents of the book:
- Part I: The journey from request to response
You will see here how the kernel boots and starts all its magic. This is the first step to understand how everything is related in this framework.
- Part II: Patterns of Dependency Injection
In this part you will learn how a bundle is the minimum unit of any development in Symfony, and how to implement dependency injection through container extension, adds all the power to our application.
The path to learn all of this passes by services and parameters that configure the concrete instance of our installation.
The author puts on the table the types of patterns for services that we can implement using Symfony: required or optional dependencies, collection, delegated creation, etc..
The same happens with the parameters patterns, the author explain us how parameters are resolved and how to override them using the compiler pass.
- Part III: Project structure
Along the whole chapter the author promotes the reusability of the code by making it available as a services for other parts of the application.
In the pages of this chapter we can find how to use some of the best practices that are development trends: slim controllers, domain managers, etc..
- Part IV: Configuration conventions
In this part we can see how to make applications that follow conventions in the configuration aspect. The reason is pretty clear: other developers will find all our stuff in the expected places.
- Part V: Security
This is a short review about implementing security measures with Symfony: how the framework allows simplifying this stuff, and how to improve the security with some configuration tricks.
Obviously, it also covers input validation, firewalls, escaping output, and some tricks to maintain our application secure in face of eventual hacking attacks.
- Part VI: Using annotations
With an introduction through Doctrine annotations this chapter dives into using of annotations in our project for general purposes.
- Part VII: Being a Symfony Developer
This is for me the most polemic chapter and the one I have been getting more profit from. With a lot of tricks and advices, you probably will find interesting all the exposed concepts. Do not wait to put all these things in practice in your own projects.
This is definetly a must have book for all those developers that are currently using Symfony framework, as well others that want start using it.
A really useful tool that allows you not only to understand better the internals of Symfony, but also as a way to become a better developer in a broad sense.