Development

Documentation/nl_NL/book/1.0/01-Introducing-Symfony

You must first sign up to be able to contribute.

Version 10 (modified by Stefan.Koopmanschap, 10 years ago)
small typo and navigation to next chapter

Hoofdstuk 1 - Introductie

Wat kan symfony voor je doen? Wat is er nodig om het te gebruiken? Dit hoofdstuk beantwoord deze vragen.

Symfony in het kort

Een framework is bedoeld voor het stroomlijnen van applicatie ontwikkeling door standaard taken en patronen te automatiseren. Een framework voegt ook structuur toe aan de code, waardoor ontwikkelaars betere, duidelijker leesbare en makkelijker beheerbare code schrijven. Uiteindelijk maakt een framework het programmeren makkelijker, omdat complexe operaties in de applicatie alleen aanwezig zijn als simpele statements die het framework aanroepen.

Symfony is een compleet framework ontworpen om het ontwikkelen van web applicaties te optimaliseren door middel van een aantal belangrijke features. Symfony scheidt de business rules, server logica en presentatie van elkaar. Er zit een grote hoeveelheid tools en klassen in gericht op het verkorten van de ontwikkeltijd van complexe web applicaties. Daarnaast automatiseert het veelvoorkomende taken zodat de ontwikkelaar zich kan concentreren op specifieke onderdelen van de applicatie die meer tijd vergen. Het eindresultaat van deze voordelen is dat mensen niet meer iedere keer het wiel hoeven uit te vinden voor iedere nieuwe applicatie die gebouwd wordt!

Symfony is compleet geschreven in PHP5. Het is door en door getest in allerlei projecten, en wordt op dit moment al gebruikt in verschillende high-demand e-business websites. Het is compatible met de meest voorkomende database systemen, waaronder MySQL, PostgreSQL, Oracle en Microsoft SQL Server, en draait zowel op *nix, Windows and Apple platformen.

Functionaliteiten

Symfony is ontwikkeld om aan de volgende eisen te voldoen:

  • Makkelijk te installeren en configureren op bijna alle platformen (en gegarandeerd op *nix en Windows)
  • Database onafhankelijk
  • Makkelijk om in de meest-voorkomende gevallen te gebruiken, maar wel flexibel genoeg om aan te passen aan complexe wensen
  • Standaard configuratie ondersteunt meerderheid: alleen in onconventionele situaties moet de configuratie aangepast te worden
  • Voldoen aan de meeste best practices op het gebied van web ontwikkeling, gebruik van design patterns
  • Klaar voor de enterprise - aan te passen aan IT beleid en architectuur, en stabiel genoeg voor lange-termijn projecten
  • Zeer leesbare code, met phpDocumentor commentaar, zodat onderhoud zeer makkelijk wordt
  • Makkelijk om uit te breiden, voor integratie met externe libraries

Geautomatiseerde web functionaliteiten

De meeste van de standaard functionaliteiten van web projecten zijn in Symfony geautomatiseerd, zoals:

  • Ingebouwde internationalisatie laag staat zowel data and interface vertaling makkelijk toe
  • Presentatielaag maakt gebruik van templates zodat HTML ontwerpers zonder kennis van het framework hun werk kunnen doen. Helpers zorgen voor een minimum van code in deze presentatielaag.
  • Automatische validatie en populatie van formulieren, zodat de validiteit van data in de database wordt gewaarborgd en gebruikers prettiger met formulieren werken
  • "Output escaping" zorgt voor meer veiligheid en minder corrupte informatie op het scherm
  • Minder verbruik van bandbreedte en server load door cache management
  • Ingebouwde authenticatie en credential functionaliteit zorgt voor het gemakkelijk opzetten van beveiligde applicaties of onderdelen
  • Ingebouwde ondersteuning voor zoekmachine-vriendelijke URLs door middel van het routing systeem
  • E-mail en "API" management zorgen voor applicaties die verder gaan dan de standaard browser interactie
  • Automatische paginatie, sortering en filtering zorgen voor makkelijkere en duidelijke lijsten
  • Enorm krachtige uitbreidbaarheid met dank aan "factories", plugins en "mixins"
  • Zeer makkelijke implementatie van AJAX interactie met dank aan one-liner helpers om javascript-effecten te genereren die in iedere browser correct werken

Ontwikkelomgeving en gereedschappen

Om aan de eisen van enterprises te voldoen die eigen coding guidelines en project management regels hebben, kan Symfony volledig worden aangepast. Het bied standaard verschillende ontwikkelomgevingen en er worden meerdere gereedschappen meegeleverd die standaard software-engineering taken automatiseren:

  • Code generatie zorgt voor snelle prototypes en simpele back-end administratiesystemen
  • Ingebouwde unit- en functionele test frameworks zorgen voor perfecte ondersteuning van test-gedreven ontwikkeling
  • Het debug paneel versnelt het vinden van problemen door zo veel mogelijk informatie te geven over de pagina waar een ontwikkelaar aan zit te werken
  • De command-line interface automatiseert de deployment van applicaties
  • Live configuratie-aanpassingen zijn mogelijk
  • Logging functionaliteit geeft beheerders volledige details over de activiteiten binnen een applicatie

Wie heeft symfony gemaakt en waarom?

De eerste versie van symfony werd uitgebracht in Oktober 2005 door project oprichter Fabien Potencier, mede-auteur van dit boek. Fabien is de CEO van Sensio (http://www.sensio.com), een Frans web bureau bekend om zijn innovatieve kijk op web ontwikkeling.

In 2003 heeft Fabien heel wat tijd besteed om bestaande open source ontwikkeltools voor web applicaties in PHP te onderzoeken. Hij vond geen enkele die voldeed aan de eerder omschreven eisen. Toen PHP 5 werd uitgebracht besloot hij dat de beschikbare tools een volwassen genoeg stadium hadden bereikt om geintegreerd te worden in een volledig framework. Hij ging vervolgens een jaar werken aan de kern van symfony, waarbij hij zijn werd baseerde op het Mojavi Model-View-Controller (MVC) framework, de Propel object-relational mapping (ORM), en de Ruby on Rails template helpers.

Fabien bouwde symfony in eerste instantie voor Sensio's projecten, omdat het hebben van een effectief framework een ideale manier is om applicaties sneller en efficienter te bouwen. Het maakt web ontwikkeling ook intuitiever, en de resulterende applicaties zijn robuuster en makkelijker te onderhouden. Het framework bewees zichzelf toen het werd gebruikt om een e-commerce website te bouwen voor een lingerieketen, waarna het werd toegepast op andere projecten.

Na het succesvolle gebruik van symfony in een aantal projecten besloot Fabien het framework uit te brengen onder een open source licentie. Hij deed dit om zijn werk te doneren aan de gemeenschap, om gebruik te kunnen maken van feedback van gebruikers, als showcase voor Sensio's ervaring, en omdat het leuk is om te doen.

Waarom "symfony" en niet "FooBarFramework?"? Omdat Fabien een korte naam wou waarin de s van Sensio was verwerkt, en de f van framework -- makkelijk te onthouden en niet te associeren met een andere ontwikkeltool. Ook omdat hij niet van hoofdletters houd. symfony was het beste alternatief, ook al is het niet compleet Engels, en het was nog beschikbaar als projectnaam. Het alternatief was "baguette".

Voor symfony om een succesvol open source project te zijn was het nodig om uitgebreide documentatie te hebben, in het Engels, zodat veel mensen het zouden gebruiken. Fabien vroeg Sensio-collega François Zaninotto, de andere auteur van dit boek, om in de code te graven en een online boek erover te schrijven. Het duurde nogal even, maar toen het project werd gepubliceerd, was het goed genoeg gedocumenteerd om een groot aantal ontwikkelaars aan te trekken. De rest is geschiedenis.

De Symfony Gemeenschap

Zodra de symfony website (http://www.symfony-project.com/) werd gelanceerd werd het framework door veel ontwikkelaars vanuit de hele wereld gedownload en geinstalleerd, werd de online documentatie gelezen, en werden de eerste applicaties met symfony gebouwd. Langzaam maar zeker ontstond er een "buzz".

Web applicatie frameworks werden steeds populairder in die tijd, en de vraag naar een volledig framework in PHP was hoog. Symfony bood een overtuigende oplossing dankzij de indrukwekkende kwaliteit van de code en de grote hoeveelheid documentatie -- twee grote voordelen tegenover de andere spelers in de framework categorie. Contributeurs kwamen snel boven drijven, met voorstellen voor aanpassingen en verbeteringen, die de documentatie proeflazen, en andere hoognodige taken uitvoerden.

De publieke source repository en het ticketing systeem bieden een varieteit van manieren om mee te helpen, en alle vrijwillige hulp is welkom. Fabien is nog steeds de belangrijkste committer in de trunk van de source repository, en garandeerd de kwaliteit van de code.

Vandaag is het symfony forum en de Internet Relay Chat (IRC) en zijn de verschillende mailinglists ideale ondersteuningskanalen, waarbij het lijkt dat iedere vraag een gemiddelde van 4 antwoorden krijgt. Nieuwkomers installeren symfony iedere dag, en de wiki en code snippets secties bevatten inmiddels een groot aantal door gebruikers aangedragen documentatie. het aantal bekende symfony applicaties neemt gemiddeld met 5 per week toe.

De symfony gemeenschap is de derde kracht van het framework, en we hopen dat je lid wordt van die gemeenschap na het lezen van dit boek.

Is Symfony voor Mij?

Of je nou een PHP 5 expert bent of een nieuwkomer in het bouwen van web applicaties, je kan symfony gebruiken. De belangrijkste factor in het beslissen of je dit wel of niet wil is de grootte van je project.

Als je een simpele website wil ontwikkelen met vijf tot toen pagina's, weinig toegang tot een database, en geen verplichtingen met betrekking tot performance of het bieden van documentatie, dan moet je alleen PHP blijven gebruiken. Je zal dan weinig winnen in het gebruik van een web applicatie framework, en het gebruik van object orientatie of het MVC model zullen je ontwikkelproces alleen maar vertragen. Overigens is symfony niet geoptimaliseerd om te efficient te draaien op gedeelde servers waar PHP scripts alleen kunnen draaien via een Common Gateway Interface (CGI).

Aan de andere kant, als je meer complexe web applicaties ontwikkelt, met zware business logica, dan is PHP alleen niet genoeg. Als je van plan bent om in de toekomst je applicatie te onderhouden en uit te breiden, dan moet je code lichtgewicht, leesbaar en effectief zijn. Als je gebrui wil maken van de laatste vernieuwingen in gebruikersinteractie (zoals AJAX) op een intuitieve manier, dan moet je geen honderden regels JavaScript schrijven. Als je leuk en snel wil ontwikkelen, dan zal PHP alleen een teleurstelling zijn. In al deze situaties is symfony voor jou.

En, natuurlijk, als je professioneel web ontwikkelaar bent, dan ken je al de voordelen van het gebruik van web applicatie frameworks, en heb je er een nodig die volwassen is, goed gedocumenteerd, met een grote gemeenschap. Zoek niet verder, want symfony is jouw oplossing.

Als je een visuele demonstratie wil, kijk dan naar de screencasts op de symfony website. Daar zul je zien hoe snel en leuk het is om applicaties met symfony te ontwikkelen.

Fundamentele Concepten

Voordat je begint met symfony moet je een aantal basisconcepten begrijpen. Het staat je vrij om alvast verder te lezen als je de betekenis kent van OOP, ORM, RAD, DRY, KISS, TDD, YAML, and PEAR.

PHP 5

symfony is ontwikkeld in PHP 5 (http://www.php.net/) en toegewijd tot het bouwen van web applicaties in diezelfde taal. Daarom is het nodig om een sterk begrip te hebben van PHP 5 om het meeste uit het framework te halen.

Ontwikkelaars die al PHP 4 kennen maar nog geen PHP 5 moeten zich vooral richten op het leren van het nieuwe object-georienteerde model van de taal.

Object-Georienteerd Programmeren (OOP)

Object-Georienteerd Programmeren (OOP) zal niet in dit hoofdstuk worden uitgelegd. Dat heeft een volledig eigen boek nodig! Omdat symfony uitgebreid gebruik maakt van de object-georienteerde mechanismen die sinds PHP 5 beschikbaar zijn, is OOP een vereiste om symfony te leren.

Wikipedia legt OOP als volgt uit:

Het idee achter object-georienteerd programmeren is dat een computerprogramma kan worden gezien als een verzameling individuele eenheden, ofwel objecten, die samenwerken, tegenover de traditionele kijk hierop waarbij een programma kan worden gezien als een verzameling functies, of simpelweg een lijst met instructies aan de computer.

PHP 5 implementeert de object-georieteerde paradigmes van klassen, objecten, methodes, overerving, en veel meer. Mensen die niet bekend zijn met deze concepten worden geadviseerd om de gerelateerde PHP documentatie te lezen, die beschikbaar is op http://www.php.net/manual/en/language.oop5.basic.php.

Magische Methodes

Een van de krachten van PHP's object mogelijkheden is het gebruik van magische methodes. Dit zijn methodes die makkelijk het standaard gedrag van klassen kan aanpassen zonder de rest van de code aan te passen. Ze maken de PHP syntax minder uitgebreid en makkelijker uitbreidbaar. Ze zijn makkelijk te herkennen, want de namen van magische methodes beginnen altijd met twee underscores ().

Bijvoorbeeld, wanneer een object wordt weergegeven, zoekt PHP impliciet naar een methode genaamd __toString() om te kijken of de ontwikkelaar een eigen formaat van weergave heeft gedefinieerd:

<?php
$myObject = new myClass();
echo $myObject;
// Zoekt naar een magische methode
echo $myObject->__toString();

Symfony gebruikt magische methodes, dus je moet dit concept goed begrijpen. Ze worden omschreven in de PHP documentatie (http://www.php.net/manual/en/language.oop5.magic.php).

PHP Extensie en Applicatie Repository (PEAR)

PEAR is "een framework en distributiesysteem voor herbruikbare PHP componenten." PEAR laat je toe om PHP scripts te downloaden, installeren, upgraden en de-installeren. Wanneer je een PEAR package gebruikt, hoef je je geen zorgen te maken over waar je deze scripts laat, hoe ze beschikbaar te stellen, of hoe je de command-line interface (CLI) moet uitbreiden.

Pear is een gemeenschap-gedreven project geschreven in PHP, en wordt standaard meegeleverd in de officiele PHP distributies.

De PEAR website, http://pear.php.net/, bied documentatie en packages gegroepeerd per categorie.

PEAR is de meest professionele manier om externe libraries te installeren in PHP. Symfony adviseert het gebruik van PEAR om een centraal installatiepunt te houden verspreid over meerdere projecten. De symfony plug-ins zijn PEAR packages met een speciale configuratie. Het symfony framework zelf is beschikbaar als PEAR package.

Je hoeft niet alles te weten over de PEAR syntax om symfony te kunnen gebruiken. Je moet echter wel begrijpen wat het doen en je moet het geinstalleerd hebben. Je kan nakijken of PEAR is geinstalleerd door op je computer in een CLI het volgende commando in te typen:

> pear info pear

Dit commando zal je het versienummer van je PEAR installatie geven.

Het symfony project heeft een eigen PEAR repository, ookwel channel genoemd. Let wel op dat channels pas beschikbaar zijn sinds versie 1.4.0 van PEAR, dus je moet eerst upgraden als je versienummer lager is dan dat. Om je versie van PEAR te upgraden, voer het volgende commando uit:

> pear upgrade PEAR

Object-Relational Mapping (ORM)

Databases zijn relationeel. PHP 5 en symfony zijn object-georienteerd. Om een database op een object-georienteerde manier te kunnen benaderen is een tussenlaag nodig die de object logica vertaald naar de relationele logica. Deze tussenlaag noemt met ook wel object-relational mapping, of ORM.

Een ORM bestaat uit objecten die toegang geven tot data en die de business rules binnen zichzelf houden.

Een voordeel van een object/relationele abstractielaag is dat het voorkomt dat je een syntax gebruikt die specific is voor een gegeven database. Het vertaalt automatisch calls naar het model object naar een SQL query die is geoptimaliseerd voor de huidige database.

Dit betekent dat het makkelijk is om halverwege een project een ander database systeem te kiezen. Stel je voor dat je een snel prototype moet schrijven voor een applicatie, maar dat de klant nog niet heeft besloten welk database systeem het handigste is voor zijn situatie. Je kan dat gewoon beginnen met bouwen voor SQLite bijvoorbeeld, en later naar MySQL, PostgreSQL of Oracle switchen zodra de klant die beslissing maakt. Gewoon een enkele regel in een configuratiebestand aanpassen, en het werkt.

Een abstractielaag omwikkelt de data logica. De rest van de applicatie hoeft niets te weten over de SQL queries, en de SQL die met de database communiceert is makkelijk te vinden. Ontwikkelaars die zich specialiseren in het programmeren van databases weten ook duidelijk waar ze moeten zijn.

Het gebruik van objecten in plaats van records, en classes in plaats van tabellen, heeft nog een voordeel: Je kan nieuwe manieren van toegang tot je tabel toevoegen. Bijvoorbeeld, als je een tabel Client hebt met twee velden, FirstName? en LastName?, dan kan het zijn dat je gewoon een naam wil hebben. In een object-georienteerde wereld is dit zo simpel als het toevoegen van een nieuwe toegangsmethode in de Client class, zoals deze:

<?php
public function getName()
{
  return $this->getFirstName().' '.$this->getLastName();
}

Al die herhaalde data-toegang functies en de business logic van de data kunnen worden onderhouden binnen zulke objecten. Bijvoorbeeld, denk eens aan een class ShoppingCart? waarin je items wil bewaren (dit zijn objecten). Om het volledige bedrag van de winkelwagen voor de betaling te krijgen, kan je een getTotal() methode toevoegen, zoals deze:

<?php
public function getTotal()
{
  $total = 0;
  foreach ($this->getItems() as $item)
  {
    $total += $item->getPrice() * $item->getQuantity();
  }
  return $total;
}

En dat is het. Denk er eens over hoe lang het zou duren om een SQL query te schrijven die hetzelfde doet!

Propel, een ander open source project, is op dit moment een van de beste object/relationele abstractielagen voor PHP 5. Symfony integreert Propel in het framework, en dus zal de meeste data manipulatie in dit boek gebeuren volgens de Propel syntax. Dit boek zal een omschrijving geven van hoe Propel objecten gebruikt kunnen worden, maar voor een completere naslag is het aan te raden de propel website (http://propel.phpdb.org/trac/) te bezoeken.

Rapid Application Development (RAD)

Webapplicaties programmeren is lang traag en saai werk geweest. Gebruikmakend van standaard ontwikkelmethodieken (zoals Rational Unified Process), kon de ontwikkeling van web applicaties pas beginnen nadat een complete set van randvoorwaarden was samengesteld, UML diagrammen waren getekend en een vracht aan voorlopige documentatie was opgesteld. Dit had als oorzaak de algemene ontwikkelsnelheid, het gebrek aan veelzijdigheid van programmeertalen (je moest bouwen, compileren, herstarten en wie weet wat nog meer, vóór je een programma kon zien werken) en --het meest belangrijk-- klanten veranderden niet constant hun wensen en eisen.

Vandaag de dag is het zakelijk verkeer sneller en klanten neigen snel hun mening te veranderen terwijl het project vordert. Uiteraard verwachten zij dat het ontwikkelteam op hun wensen inspeelt en snel de structuur van een applicatie wijzigt. Gelukkig maken scripttalen als Perl en PHP het mogelijk snel andere programmeerstrategiën toe te passen, zoals rapid application development (RAD) of Agile software development.

Eén van de ideeën achter deze methodieken is om snel te kunnen starten met ontwikkelen zodat de klant snel een werkend prototype kan beoordelen en zo kan bijsturen. De applicatie wordt gebouwd via een zich herhalend proces, waarbij steeds steeds rijkere versies qua functionaliteit worden vrijgegeven in korte ontwikkelcycli.

De gevolgen voor de ontwikkelaar zijn legio. Een ontwikkelaar hoeft niet aan de toekomst te denken wanneer deze een functie invoegt. De gebruikte methode moet zo simpel en duidelijk mogelijk zijn. Dit is mooi weergegeven door de spreuk van het KISS principe: Keep It Simple, Stupid (vert. Houd het simpel, idioot).

Wanneer de vereisten wijzigen of wanneer een functie is toegevoegd kan het zijn dat (delen van) code deels moet worden herschreven. Dit proces heet refactoring. Dit gebeurt geregeld tijdens het ontwikkelpoces. Code wordt verplaatst naar gelang het doel ervan. Duplicaatcode worden refactored op een enkele plaats volgens het DRY (Don't Repeat Yourself, vert. Herhaal jezelf niet) principe.

En om zeker te zijn dat de applicatie blijft draaien terwijl het constant verandert, heeft het een complete set unit tests nodig die geautomatiseerd kunnen worden. Indien goed geschreven zijn unit tests een goede methode om je ervan te verzekeren dat niets kapot is gegaan teerwijl er code is refactored of toegevoegd. Sommige ontwikkelmethodieken benadrukken zelfs dat tests eerst moeten worden geschreven en erna pas de code. Dit wordt test-driven development (TDD) genoemd: door tests aangedreven ontwikkeling.

Er zijn vele principes en goede ideeën over agile developement. Een van de beste en effectiefste methodieken is Extreme Programming (XP). De literatuur hierover kan je veel leren over het snel en effectief ontwikkelen van een applicatie. Een goed begin is de XP series boeken, geschreven door Kent Beck (Addison Wesley).

Symfony is het perfecte RAD gereedschap. Sterker nog, het framework was gebouwd door een webbureau dat het RAD principe gebruikt voor zijn eigen projecten. Dit houdt in dat het leren van Symfony niet zozeer het leren van een nieuwe taal inhoudt, maar meer over het toepassen van goede reflexen en beoordelingsvermogen om applicaties op een effectievere manier te kunnen bouwen.

De Symfony website biedt een stap-voor-stap handleiding die de ontwikkeling van een applicatie op een snelle/agile wijze beschrijft. Dit betreft de Askeet applicatie (http://www.symfony-project.com/askeet) en is verplicht leesvoer voor hen die meer over agile development willen weten.

YAML

Volgens de officiële YAML website (http://www.yaml.org/) is YAML een "rechtdoorzee, door machines te parsen gegevens serialisatie formaat voor menselijke leesbaarheid en interactie met scripttalen". Oftewel, YAML is een heel simpele taal om gegevens te beschrijven op een XML-achtige manier, maar met een veel simpelere syntax. Het is in het bijzonder bruikbaar om gegevens te beschrijven die naar arrays of hashes vertaald moeten worden, zoals hieronder:

<?php
$house = array(
  'family' => array(
    'name'     => 'Doe',
    'parents'  => array('John', 'Jane'),
    'children' => array('Paul', 'Mark', 'Simone')
  ),
  'address' => array(
    'number'   => 34,
    'street'   => 'Main Street',
    'city'     => 'Nowheretown',
    'zipcode'  => '12345'
  )
);
?>

Deze PHP array kan automatisch aangemaakt worden door de volgende YAML string te parsen:

house:
  family:
    name: Doe
    parents:
      - John
      - Jane
    children:
      - Paul
      - Mark
      - Simone
  address:
    number: 34
    street: Main Street
    city: Nowheretown
    zipcode: "12345"

In YAML, de structuur is weergegeven door middel van inspringing. Opvolgingslijsten worden voorafgegaan door een streepje en sleutel/waarde paren binnen een mapping worden gescheiden met een dubbele punt. YAML heeft ook een korte notatie om dezelfde structuur te beschrijven in minder regels, waarbij arrays worden genoteerd met [] en hashes met {}. Op deze manier kan de voorgaande YAML set op de volgende, kortere wijze geschreven worden:

house:
  family: { name: Doe, parents: [John, Jane], children: [Paul, Mark, Simone] }
  address: { number: 34, street: Main Street, city: Nowheretown, zipcode: "12345" }

YAML is een acronym voor Yet Another Markup Language wordt uitgesproken als "yamel." Het formaat bestaat al sinds 2001 en YAML parsers bestaan voor een grote hoeveelheid programmertalen.

De specificaties van het YAML formaat zijn beschikbaar op http://www.yaml.org/.

Zoals je kan zien is YAML een stuk sneller te schrijven dan XML (geen sluittags of expliciete quotes). Daarnaast is het krachtiger dan .ini bestanden (welke geen hiërarchie ondersteunen). Dit zijn de redenen waarom Symfony YAML gebruikt als de voorkeurstaal voor het opslaan van configuraties. Je zult veel YAML bestanden tegenkomen in dit boek, maar het werkt zo vanzelfsprekend dat er geen noodzaak zal zijn er meer over te leren.

Samenvatting

Symfony is een PHP 5 gebaseerd applicatie raamwerk. Het voegt een laag toe bovenop de PHP taal, door middelen te bieden om de ontwikkeling van complexe webapplicaties te versnellen. Dit boek vertelt je er alles over, je dient slechts bekend te zijn met de basisconcepten van hedendaagse programmeertechnieken in het bijzonder om het te begrijpen, in het bijzonder objectgeoriënteerd programmeren (OOP), object-relational mapping (ORM) and rapid application development (RAD). De enige verplichte eis aan technische achtergrond is de kennis van PHP 5.

Hoofdstuk 2 - Symfony's Code Ontdekken >