Sebastian Bergmann - PHP

PHP Summit in London

nospam@example.com (Sebastian Bergmann) — Sat, 25 Feb 2012 12:00:00 +0100

With all PHP topics, nothing counts more than their practical application. This is why thePHP.cc offers highly interactive and practical workshops. Based on their own specific needs and questions, the attendees decide on the topics that are covered. They experience the development of new code at first hand, following their own agendas rather than those of the three trainers.

The first PHP Summit with workshops presented in English will be in London in May. And these are the workshops:

Update PHP: Leverage New Features and Technologies

Workshop with Sebastian Bergmann

PHP 5.3 and PHP 5.4 help developers in their daily routine with a plethora of relevant improvements. Get to know the innovative features of these new versions and learn how to apply them in practice. Discover the potential of emerging technologies such as memcached or ZeroMQ and learn how they can solve your problems.

Unclean PHP: Identify, Refactor, Avoid

Workshop with Sebastian Bergmann

Sooner or later unclean code becomes a damn nuisance. And not only for the developer who has to maintain it. Changes and extensions make the code more and more uneconomic. Learn how to detect unclean code using static analysis and how to refactor it with testability and maintainability in mind. Learn how to avoid unclean code by applying the SOLID principles and writing sustainable code.

Best Practices: From the Real World for the Real World

Workshop with Arne Blankerts

Of course you can reinvent the wheel every day. You just do not have the time to do so, plus it is no fun, and bugs can creep into the same places over and over again. Clever solutions exist for many bread-and-butter problems that only deviate slightly from already solved ones. This workshop shows the programming concepts to achieve this in a live coding session that is entirely driven by the audience's requests and invites to a discussion of tools and techniques.

Safely Prepared for Errors

Workshop with Arne Blankerts

Programs and websites have errors. Always. They become apparent when users enter wrong, invalid, or unexpected input, when access to the database is suddenly not possible, or when the disk is full. Various approaches to safely handle these and other problems are presented and discussed in this workshop. How to correctly use exceptions, why a custom error handler can be helpful, and what debugging has to do with security these questions and more will be answered intuitively and vividly.

Object-Oriented Progamming (OOP) in PHP I: Fundamentals

Workshop with Stefan Priebsch

This workshop answers the question what object-oriented programming is all about. It gives an introduction to OOP with PHP that goes beyond the known standard examples. In addition to presenting the fundamental principals of OOP it also highlights interesting features of the Standard PHP Library (SPL) and how they can be applied in practice. In addition to imparting factual knowledge the workshop presents a mindset that allows you to avoid overly complicated approaches.

Object-Oriented Progamming (OOP) in PHP II: Advanced Topics

Workshop with Stefan Priebsch

This workshop introduces attendees that are already familiar with the foundations of OOP to advanced topics such as Dependency Injection, abstract classes, and interfaces as well as best practices for successful object-oriented programming. A live coding session makes the presented techniques tangible. In addition to imparting factual knowledge the workshop shows that good solutions are simple solutions: simple objects are easier to reuse and test and thus help to avoid mistakes.

Testing PHP Application: Fundamentals

Workshop with Sebastian Bergmann

This workshop imparts the fundamental information and skills for the writing of Unit Tests, Database Integration Tests, Edge-to-Edge Tests, and End-to-End Tests with PHPUnit. You will learn everything you need to know to write, organize, and run tests with PHPUnit.

Testing PHP Applications: Advanced Topics

Workshop with Sebastian Bergmann

Craftily leverage PHPUnit: Attendees of this workshop will learn PHPUnit best practices and field-tested strategies for the introduction of testing measures into legacy projects. A range of examples will help the attendees to develop a sense for hard-to-test code and bad tests. They will learn how to refactor legacy code for testability and how to avoid common pitfalls when writing unit tests.

Insider's Tip XML: Applications the Smart Way

Workshop with Arne Blankerts

XML is the standard language for data exchange on the Web and is concealed from the end user's eyes in many file formats (such as Microsoft Office, for instance). This workshop shows that working with XML can be fun when the transported data is valid and the access leverages efficient APIs. We extend PHP's DOM API with custom methods and implement localization support in PHP during a Live Coding session. The definition of XSD schemas for the validation of XML data as well as the usage of XPath as a query language will be demonstrated. Effective error handling is also a topic.

Tuning for Web Applications

Workshop with Arne Blankerts

He who takes a clumsy path towards a solution will get into trouble he does not want to be in. Usually this happens to the detriment of performance and scalability. This workshop shows uses a plethora of real-world examples to show how you can avoid such bottlenecks in current architectures and superstructures from the get-go. It invites to reconsider and adapt your way of thinking.

Design Patterns I: The Most Important Standards

Workshop with Stefan Priebsch

Why reinvent the wheel every time? The developers of this workshop will get to know important design patterns that have proven themselves especially in PHP-based web applications. Problems that commonly occur in practice will be presented and solutions for them will be coded live. Benefits and drawbacks as well as applications and common implementation mistakes will be presented when the standard design patterns are discussed.

Design Patterns II: Integrating Sophisticated Patterns

Workshop with Stefan Priebsch

The workshop covers topics such as Temporal Patterns, the persisting of objects in relational and NoSQL databases, or Enterprise Integration Patterns. Typical problems are presented and analyzed. The (lesser known) design patterns that are used to solve these problems will provide the attendees with knowledge that is valuable to their daily routine.

Modern Version Control with Git

Workshop with Sebastian Bergmann

Git is a powerful version control system that allows you to reliably manage all changes made to all components (code, configuration, ) of your software. This is the foundation for the continuous integration of your project. This workshop imparts the fundamentals for the usage of Git as well as best practices and processes for the development, release management, and deployment of your software that will make your team noticeable more effective.

Continuous Integration with Jenkins

Workshop with Sebastian Bergmann

When you want to measure and control the quality of your software during development and operation then you can profit from setting up an environment for the continuous integration of your PHP projects. With the combination of dynamic and static testing techniques you automate recurring tasks, stay up-to-date on the state of your software's quality, and minimize risks to your project's success. Attendees of this workshop will learn how to leverage Jenkins for the continuous integration and inspection of their PHP software.

It is best to expect the worst!

Workshop with Arne Blankerts

In times of constant break-in attempts by bored users it makes sense to always expect attacks from the Internet. Even allegedly secure structures provide adept hackers with no opposition worth mentioning. Responsible developers just have to know how hackers would attack their application or infrastructure. This workshop imparts fundamental knowledge and demonstrates in a Live Coding session what CSRF, XSS, or SQL Injections are, how you can make the life of attackers harder, and how effective countermeasures can be implemented.

Attack! What makes attacks on the Web successful

Workshop with Arne Blankerts

Applications are permanently exposed to attacks on the Internet. Attackers do not rest to contrive means and ways to inflict damage. Attendees of this workshop switch sides and attack a Black Box demo application. They learn how attackers gather information, exploit security holes, and take over servers. The workshop imparts knowledge about finding and closing security issues and how to implement countermeasures to attacks.

Framework: Basics in Three Hours

Workshop with Stefan Priebsch

This workshop provides answers to many questions about the structure of web applications and writing testable, maintainable, and extensible code by giving a practical example. Important design patterns and best practices will be demonstrated. Attendee feedback and questions will steer this session. The goal is a better understanding for the main concepts of frameworks.

Why the Tower of Pisa is Leaning

Workshop with Stefan Priebsch

The importance of non-functional aspects for technical decisions is often underestimated or completely overlooked. The more complex the issue is the more likely it is that ignoring the non-functional aspects will result in problems that cannot be solved easily later on. He who thinks about architecture before development solves tomorrow's problems today. This workshop presents various architectural patterns for web applications and also covers current trends such as Distributed Caching, Message Queues, and NoSQL. It introduces the audience to tried and true building blocks that allow the development of highly performant and scalable web applications with PHP.

With a twinkle in their eyes and a dash of fun, Sebastian Bergmann, Arne Blankerts, and Stefan Priebsch explain development methods and tools as well as present trends and concepts. This is efficient learning in a relaxed environment. Take advantage of this uniquely intense form of knowledge transfer at an unbeatable cost-to-benefit ratio and reserve your seat today!

PHP Summit in München

nospam@example.com (Sebastian Bergmann) — Fri, 03 Feb 2012 05:15:29 +0100

This blog posting is in German as the event it relates to is German-only.
Sorry for the inconvenience.

Bei allen PHP-Themen zählt nichts mehr als die Praxis. Deshalb bieten wir unsere Power-Workshops interaktiv und mit intensivem Praxisbezug an. Über die behandelten Themen entscheiden die Teilnehmer mit ihren konkreten Fragen. Anstelle von Frontalunterricht erleben sie die Entwicklung von neuem Code unmittelbar. Mit Augenzwinkern und Spaß erläutern Sebastian Bergmann, Arne Blankerts und Stefan Priebsch Entwicklungsmethoden und Tools und stellen Trends und Konzepte vor.

Der nächste PHP Summit findet im März in München statt. Und das sind die Workshops:

Update PHP: Neue Features und Technologien nutzen

Workshop von Sebastian Bergmann

PHP 5.3 und PHP 5.4 überzeugen im Programmieralltag durch eine Fülle relevanter Vereinfachungen. Lernen Sie die innovativen Features und geschickte Einsatzmöglichkeiten der neuen Versionen kennen. Entdecken Sie das Lösungspotenzial aktueller Technologien aus dem PHP-Umfeld (memcached, ZeroMQ ) für Ihre Fragestellungen.

Weg mit Strubbelcode: identifizieren verbessern vermeiden

Workshop von Sebastian Bergmann

Früher oder später wird unsauber geschriebener Code zum Ärgernis. Nicht nur für den, der ihn warten muss. Änderungen und Erweiterungen können im Extremfall den Code unwirtschaftlich machen. Lernen Sie schlechten Code durch statische Codeanalyse aufzufinden und in test- und wartbaren Code umzuschreiben. Lernen Sie mithilfe der SOLID-Prinzipien, nachhaltig wartbaren Code zu schreiben.

Best Practices aus dem Alltag für den Alltag

Workshop von Arne Blankerts

Natürlich könnte man das Rad jeden Tag neu erfinden. Meist fehlt dafür die Zeit, Spaß macht es auch nicht und Fehler können sich so immer wieder an denselben Stellen einschleichen. Für die vielen alltäglichen Probleme, die nur geringfügig von schon vorhandenen Lösungen abweichen, gibt es clevere Ansätze, die das Leben leichter machen. In einer komplett vom Auditorium gesteuerten Live Session zeigt der Workshop dafür programmatische Konzepte und lädt zur Diskussion über Tools und klassische Fragestellungen ein.

Auf Fehler sicher vorbereitet sein

Workshop von Arne Blankerts

Programme und Webseiten enthalten Fehler. Immer. Sie werden sichtbar, wenn Benutzer falsche, ungültige oder unerwartete Eingaben machen, der Zugriff auf die Datenbank plötzlich unmöglich ist oder die Festplatte überläuft. Um solche und andere Probleme sicher abzufangen, gibt es verschiedene Ansätze, die hier vorgestellt und diskutiert werden. Wie man Exceptions richtig anwendet, warum ein eigener Error Handler hilfreich ist und dass Debugging viel mit Sicherheit zu tun hat, vermittelt der Workshop lebendig und anschaulich.

Objektorientierte Programmierung (OOP) in PHP I: Basiswissen

Workshop von Stefan Priebsch

Der Workshop klärt die Frage, was es mit der objektorientierten Programmierung eigentlich auf sich hat. Jenseits der bekannten Standardbeispiele führt er praktisch in die OOP mit PHP ein. Dabei werden neben den Grundlagen und zentralen Prinzipien der OOP interessante Features beispielsweise aus der Standard PHP Library (SPL) vorgestellt und ihr sinnvoller Praxiseinsatz vorgeführt. Neben Faktenwissen wird eine Denkweise vermittelt, die es erlaubt, unnötig komplizierte Ansätze von vornherein zu umgehen.

Objektorientierte Programmierung (OOP) in PHP II: Aufbauwissen

Workshop von Stefan Priebsch

Der Workshop zeigt Teilnehmern, die mit den Grundlagen der OOP vertraut sind, fortgeschrittene Techniken wie Dependency Injection, abstrakte Klassen, Interfaces und Best Practices für erfolgreiche OOP. Eine Live-Coding-Session macht den Einsatz der vorgestellten Techniken in der Praxis erfahrbar. Außer Faktenwissen zeigt der Workshop, dass gute Lösungen einfache Lösungen sind: Einfache Objekte sind leichter wieder zu verwenden und vermeiden Fehler.

PHP-Anwendungen testen: Basiswissen

Workshop von Sebastian Bergmann

Der Workshop vermittelt grundlegende Kenntnisse und Fähigkeiten im Einsatz von PHPUnit bei Unit Tests, Datenbank-Interaktionstests, Edge-to-Edge- Tests und End-to-End-Tests. Sie lernen alles, was Sie über das Schreiben, Ausführen und Organisieren von Unit Tests mit PHPUnit beherrschen müssen.

PHP-Anwendungen testen: Aufbauwissen

Workshop von Sebastian Bergmann

PHPUnit clever einsetzen: Die Teilnehmer lernen die besten Praktiken beim Einsatz von PHPUnit und erprobte Strategien bei der Einführung von Testmaßnahmen an vorhandener Software kennen. Anhand zahlreicher Beispiele entwickeln Sie einen Blick für schlechte Tests und lernen, sie zu verbessern, schwer testbaren Code zu identifizieren und Legacy-Code Schritt für Schritt testbar zu machen.

Geheimtipp XML: Die smarte Art der Anwendung

Workshop von Arne Blankerts

XML ist das Standardformat für den Datenaustausch im Web und verbirgt sich in vielen, für Endanwender oft nicht sichtbaren Dateiformaten (z. B. aktuelle MS-Office-Versionen) und Formen. Der Workshop zeigt, dass XML richtig Spaß machen kann, wenn die übermittelten Daten validiert werden und der Zugriff mit effiziente APIs erfolgt. In der Live Session erweitern wir das DOM-API von PHP um eigene Methoden und unterstützen die Lokalisierung durch PHP. Eigene XSD Schemas zur Validierung werden definiert und der Einsatz von XPath als Abfragesprache vorgeführt. Vermittelt wird auch der Einblick in eine wirklich effektive Fehlerbehandlung.

Neu: Tuning für Web-Anwendungen

Workshop von Arne Blankerts

Wer einen ungeschickten Weg zur Lösung beschreitet, handelt sich Probleme ein, die er gar nicht haben möchte. In der Regel geht das zulasten des Tempos und der Skalierbarkeit. Wie man solche Schwachpunkte in gängigen Aufbauten und Architekturen vorab erkennt und durch bessere Konzepte von vornherein vermeiden kann, zeigt dieser Workshop an zahlreichen Praxisbeispielen. Eigene Denk- und Herangehensweisen können überprüft und modifiziert werden.

Entwurfsmuster I: Die wichtigsten Standards

Workshop von Stefan Priebsch

Warum das Rad jedes Mal neu erfinden? Die Teilnehmer lernen in diesem Workshop wichtige Entwurfsmuster kennen, die sich in PHP-Webanwendungen besonders bewährt haben. Häufig in der Praxis auftretende Schwierigkeiten werden vorgeführt und Lösungen werden live programmiert. Vor- und Nachteile sowie Einsatzmöglichkeiten und typische Fehler bei der Anwendung von Standardmustern werden ausführlich erläutert und diskutiert.

Entwurfsmuster II: Integration anspruchsvoller Patterns

Workshop von Stefan Priebsch

Der Workshop behandelt Themenstellungen wie temporale Patterns, das Speichern von Objekten in relationale und NoSQL-Datenbanken oder Enterprise Integration Patterns mit Schwerpunkten, die von den Teilnehmern frei festgelegt werden. Eine Reihe typischer Probleme wird vorgeführt und analysiert. Die zu ihrer Lösung eingesetzten (wenig bekannten) Entwurfsmuster vermitteln den Teilnehmern fortgeschrittene Kenntnisse, die im Alltag wertvoll sind.

Moderne Versionskontrolle mit Git

Workshop von Sebastian Bergmann

Git ist ein mächtiges Versionsverwaltungssystem, mit dem Sie alle Bestandteile Ihrer Software durch alle Änderungen und Versionen zuverlässig verfolgen können. Damit schaffen Sie die Grundlage für die kontinuierliche Integration der Software. Der Workshop vermittelt Grundlagen für den Einsatz von Git, Best Practices und Prozesse für Entwicklung, Release-Management und Deployment, die Ihre Teamarbeit spürbar effektiver machen.

Kontinuierliche Integration mit Jenkins

Workshop von Sebastian Bergmann

Wer die Qualität seiner Software während der Entwicklung und im Betrieb messen und kontrollieren will, profitiert vom Einrichten einer Umgebung, in der PHP-Projekte kontinuierlich integriert werden können. Mit der Kombination dynamischer und statischer Testverfahren automatisieren Sie wiederkehrende Aufgaben, sind über die Softwarequalität auf dem Laufenden und minimieren Projektrisiken erfolgreich. Der Workshop vermittelt die Grundlagen der kontinuierlichen Integration und Inspektion von PHP-Software. Sie üben Installation, Konfiguration und Betrieb von Jenkins für PHP-Projekte.

Am besten mit dem Schlimmsten rechnen!

Workshop von Arne Blankerts

In Zeiten ständiger Einbruchsversuche durch gelangweilte Anwender ergibt es Sinn, wirklich immer mit Angriffen aus dem Internet zu rechnen. Auch vermeintlich sichere Strukturen bieten versierten Hackern oft keinen nennenswerten Widerstand. Verantwortungsbewusste Entwickler müssen wissen, wie man der eigenen Anwendung oder Infrastruktur schaden könnte. Der Workshop vermittelt grundlegende Zusammenhänge und zeigt in einer Live Session, was Begriffe wie XSS, CSRF oder SQL-Injection bedeuten, wie man Angreifern das Leben schwer macht und wirksame Lösungen implementiert.

Attacke! Was Angriffe im Web erfolgreich macht

Workshop von Arne Blankerts

Anwendungen sind im Internet permanent Angreifern ausgesetzt. Im Workshop wechseln die Teilnehmer die Seiten und greifen selbst eine Demo-Blackbox-Anwendung an. Sie lernen, wie Angreifer Informationen sammeln, Sicherheitslücken ausnutzen und Server übernehmen. Vermittelt werden Methoden, um Lücken zu finden, sie zu schließen und Angriffe abzufangen. Der abschließende Blick in den Quellcode sensibilisiert für Schwachstellen und zeigt, wie man sie behebt.

Framework: Basics in drei Stunden

Workshop von Stefan Priebsch

Grundlegende Fragen nach der Struktur einer Webanwendung und dem Schreiben von Code, der test-, wart- und erweiterbar ist, werden an einem praktischen Beispiel beantwortet. Wichtige Entwurfsmuster und Best Practices werden vorgeführt. Feedback und Fragen der Teilnehmenden steuern den Verlauf der Session. Ziel ist ein besseres Verständnis für die wesentlichen Konzepte von Frameworks.

Warum der Turm in Pisa schief steht

Workshop von Stefan Priebsch

Nichtfunktionale Aspekte werden in ihrer Bedeutung für technische Entscheidungen oft unterschätzt oder ganz übersehen. Je komplexer die Fragestellungen desto wahrscheinlicher ist es, dass aus diesem Wegschauen Probleme resultieren, die später nicht leicht einzufangen sind. Wer sich vor der Entwicklung Gedanken zur Architektur macht, löst heute Probleme von morgen. Der Workshop zeigt Architekturmuster für Webanwendungen und geht auf aktuelle Trends wie Distributed Caching, Message Queues und NoSQL ein. Es werden erprobte Bausteine vorgestellt, mit denen hochperformante und skalierbare Webanwendungen in PHP entwickelt werden können.

Der PHP Summit bietet effizientes Lernen in entspannter Atmosphäre. Profitieren Sie von dieser einzigartig intensiven Form der Informationsvermittlung mit einem unschlagbaren Preis-Leistungs-Verhältnis und reservieren Sie sich Ihren Platz noch heute!

A Tool's Tale

nospam@example.com (Sebastian Bergmann) — Wed, 01 Feb 2012 07:30:00 +0100

When Noah Sussman asked me to give a Code as Craft Technology Talk last week when I was consulting for Etsy I immediately said yes. However, I was a bit surprised when the talk was announced under the title "An Evening with Sebastian Bergmann". When I read that title the first time, it was just minutes after Arne, Stefan and I had talked about one of our favourite scenes from "A Knight's Tale":

Chaucer: I'm a writer.

Wat: A what?

Chaucer: A wha- a what? A writer. You know, I write, with ink, and parchment. Geoffrey Chaucer's the name, writing's the game. You've probably read my book? The Book of the Duchess? No? Well, it was allegorical.

Roland: Well, we won't hold that against you, that's for every man to decide for himself.

Just like with a talk that I gave last year, I suddenly had a chain of associations in my head that I just had to follow. And down the rabbit hole I went once more ...

Hi! I have no idea why this talk is titled "An Evening with Sebastian Bergmann". I hope that this evening will turn into an interesting discussion about PHPUnit and all things testing. To break the ice, and to not appear completely unprepared, I came up with the following slides ...

So I recently talked with my friends Arne and Stefan about the movie "A Knight's Tale". Somehow the idea stuck in my head that a variation of that title might be a good idea for a talk of mine. After dismissing "A Fool's Tale" I arrived at "A Tool's Tale". So that's what we're stuck with and what I am going to try right now ...

What I just did was a variation on how Geoffrey Chaucer introduces himself in the movie.

Some time in 2001 I started to work on PHPUnit because I wanted to have something like JUnit for PHP. The initial "port" was completed within one weekend. The code was ugly because I had to emulate exceptions which PHP 4 did not have. On November 27th 2001 I checked the code into cvs.php.net.

A lot has changed since 2001. Hopefully not very many developers are still stuck with PHP 4. As of PHPUnit 2.0, which was released on July 14 2004, the day after PHP 5.0.0 was released, PHP 5 is required to run PHPUnit.

PHPUnit is neither the only testing framework nor the only quality assurance tool for PHP. Over the last years a nice ecosystem of static analysis tools started to grow.

I get this question a lot: why do only Germans work on tools that tell me that my code is bad? I do not have an answer for this, sorry. But the statement is also not true: PHP_CodeSniffer is not developed by a German.

PHP has changed and so the have the tools we use to write and maintain code. In 2006 the PHPUnit code was migrated from CVS to Subversion ...

... and in December 2009 from Subversion to Git and GitHub.

PHPUnit is no longer one big monolithic package. It has been refactored to components that are being reused by other testing frameworks, for instance. Unfortunately, this refactoring was not without problems.

PHPUnit gets more and more convenience functionality. Here are a couple of examples:

Tests can be written, both unintentionally and intentionally, in bad ways. Bad tests can lie. They can give you a false sense of security by reporting that something is tested when it really is not.

This is why I started iplementing coutermeasures against bad tests such as the (ultimately useless but still interesting) assertion counting ...

... as well as the strict execution mode.

There is code in PHPUnit that I am not proud of. I am trying to make the world a better place by eliminating one singleton at a time, for instance. Unfortunately, cleaning up code sometimes breaks things. Contrary to what a popular opinion on Twitter is, I do not like breaking backwards compatibility in PHPUnit and try really hard to avoid it.

This is a "good" example of such a backwards compatibility breakage. It happened in PHPUnit 3.6 because I eliminated a Singleton. Had I known that many developers used this API (instead of the XML configuration file) to set up a code coverage blacklist or whitelist I would probably not have done the change. If more people would have tested the release candidates leading up to PHPUnit 3.6 they could have told me ... oh well.

At this point the "Evening with Sebastian Bergmann" turned into the interesting discussion I had hoped for.

Static Analysis with HipHop for PHP

nospam@example.com (Sebastian Bergmann) — Fri, 27 Jan 2012 20:00:00 +0100

In July 2010 I already blogged about the fact that HipHop for PHP, the source code transformer that turns PHP code into C++ code that can then be compiled with g++, can also be used for static code analysis to find problems in PHP source code.

Today I started to work on a convenience wrapper for HipHop's static analyzer:

➜  ~  hphpa /usr/local/src/code-coverage/PHP
hphpa 1.0.0 by Sebastian Bergmann.

/usr/local/src/code-coverage/PHP/CodeCoverage/Filter.php
  206   TooManyArgument: $this->addFileToWhitelist($file, FALSE)

Of course the tool can also generate an XML logfile in a format that is suitable for continuous integration:

➜  ~  hphpa --checkstyle hphpa.xml --quiet /usr/local/src/code-coverage/PHP
hphpa 1.0.0 by Sebastian Bergmann.

➜  ~  cat hphpa.xml
<checkstyle>
 <file name="/usr/local/src/code-coverage/PHP/CodeCoverage/Filter.php">
  <error line="206"
         message="$this->addFileToWhitelist($file, FALSE)"
         source="TooManyArgument"/>
 </file>
</checkstyle>

PHP Training in Montréal

nospam@example.com (Sebastian Bergmann) — Wed, 04 Jan 2012 09:00:00 +0100

Together with my friends and partners from thePHP.cc, Arne Blankerts and Stefan Priebsch, I will be giving an "Advanced PHP Development" training in Montréal in March.

With all PHP topics, nothing counts more than their practical application. This is why thePHP.cc once again offers a highly interactive and practical training right before the ConFoo conference. Based on their own specific needs and questions, the attendees decide on the topics that are covered. They experience the development of new code at first hand, following their own agendas rather than those of the three trainers.

With a twinkle in their eyes and a dash of fun, Sebastian Bergmann, Arne Blankerts, and Stefan Priebsch explain development methods and tools, present trends and concepts, and perform joint code review sessions. This is efficient learning in a relaxed environment.

Topics covered include development best practices, object-oriented programming, design patterns, web application architecture, security, software quality and testing. All three trainers will be present at all times, so attendees have an unparalleled level of access to top-notch PHP expertise.

This training gives answers to every question you ever had about PHP and software development with PHP. Attendees should bring their own code and as many questions as they have.

As the training is scheduled right before the ConFoo conference and the topics covered complement its presentations, the Advanced PHP Development" training is the perfect preparation for attendees to get the most out of the conference.

Register now to secure your seat as the number of attendees is limited to ensure a beneficial learning environment.

Using CLANG/scan-build for Static Analysis of the PHP Interpreter

nospam@example.com (Sebastian Bergmann) — Fri, 16 Dec 2011 12:20:57 +0100

I have been tinkering with CLANG's static analyzer lately. This post summarizes how I installed LLVM and CLANG and performed the analysis of a build of the PHP interpreter.

First, we need to obtain the CLANG and LLVM source trees and build CLANG:

cd /usr/local/src
mkdir clang
cd clang
svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm
cd llvm/tools
svn co http://llvm.org/svn/llvm-project/cfe/trunk clang
cd ../../
mkdir build
cd build
../llvm/configure --enable-optimized --disable-assertions
make

Then we need to add the directories that contain clang, ccc-analyzer, and scan-build to our $PATH:

export PATH=/usr/local/src/clang/build/Release/bin:/usr/local/src/clang/llvm/tools/clang/tools/scan-build:$PATH

Now we can analyze the C code of PHP while compiling it using CLANG:

cd /usr/local/src/php/5.4

export CC="ccc-analyzer"
export CXX="ccc-analyzer"

scan-build ./configure
scan-build make

Once the build completes there will be a report directory with HTML files (about 1.5 GB of them) in /tmp.

Testable Code: Rockstar Edition

nospam@example.com (Sebastian Bergmann) — Sun, 11 Sep 2011 18:30:00 +0200

Saying "yes" is my default response when a friend asks for my support. But when my friend Carola Köhntopp asked me a while ago to participate in a presentation about presenting (meta alert!) at this year's PHP @ FrOSCon I committed myself to help without knowing what I would be getting myself into.

The title of Carola's presentation, "PHPopstars", was a play of words on the reality television franchise Popstars. The idea was that there were five "finalists" (Kore Nordmann, Tobias Schlitt, Judith Andresen, Kristian Köhntopp, and myself) in a competition of "PHP Speakers". Carola had asked the five of us to each prepare a 4-minute-long presentation that we were to present as part of the PHPopstars event.

My presentation was titled "Testable Code: Rockstar Edition" and here are the slides:

I am not a pop star. I do not listen to pop music. According to Lorna Jane I am a rock star. I would not describe myself as such but two years ago I came very close to feeling like a rock star when I toured the United States together with Arne and Stefan. Over the course of 14 days we presented workshops at conferences in 7 cities.

About the time when Carola had asked me about participating in PHPopstars the soundtrack for Portal 2 was released. It is titled "Songs to Test By".

This title started a chain of associations that I just had to follow. And down the rabbit hole I went.

You know where you are? You're in the jungle, baby.

You're gonna die!

Just an urchin livin' under the street
I'm a hard case that's tough to beat
I'm your charity case, so buy me something to eat
I'll pay you at another time, take it to the end of the line

Take me down to the paradise city
Where the tests are green
And the code is pretty
Take me home

Such a chain of associations is not always expedient. The one I just described is only useful when your goal is to fill a 4-minute sub-presentation in someone else's presentation.

Eleven years ago, when I presented for the first time at a conference (and at the world's first PHP conference, no less), my presentation style was drastically different from the way I present today.

Nowadays I try to find a pictorial language to reach the audience not only on the technical level (using the spoken word and with code on the slides) but also on the emotional level.

Take the above picture of a green field as an example. It resonates well with developers as they (generally) prefer development without the restrictions that legacy code impose.

The books by Nancy Duarte, "slide:ology" and "resonate", are excellent resources that help with getting a fresh perspective on presenting. However, as a technical presenter that mostly talks about code, these books are not as useful as I hope "Presentation Patterns" will be.

Avoid the hell that is global state!

Do not depend on global variables!

Do not use singletons!

Follow the Separation of Concerns design principle!

Use loosely coupled objects!

Design Patterns can help!

A good architecture leads to clean code that is easy to test as well as cheap to maintain.

Meet thePHP.cc in October

nospam@example.com (Sebastian Bergmann) — Tue, 21 Jun 2011 18:45:00 +0200

Fall season is traditionally conference season in the PHP community. This October, you will have the chance to catch all three partners of thePHP.cc -- Sebastian Bergmann, Arne Blankerts, and Stefan Priebsch -- at the following events:

PHP NW Conference 2011

Beware of the dark side, Luke!

Tutorial by Arne Blankerts

Somehow you met the impossible deadline, your project is online and you now deserve some time to relax. Other than you and me though, the internet does not sleep and your application is under constant risk of attack. Even without having access to the source code, attackers have their ways to break into applications and steal or modify private information.

Switch sides for a day and attack the demo blackbox application! Learn how attackers gather information, exploit vulnerabilities and hijack servers -- and what to do to stop them.

PHP Tester's Toolbox

Presentation by Sebastian Bergmann

Various testing tools exist to test the different aspects and layers of PHP applications. There is PHPUnit for Unit Testing (and Test-Driven Development), Behat for Acceptance Testing (and Behaviour-Driven Development), Selenium for System Testing, and a plethora of tools for testing non-functional aspects such as performance and security.

This presentation provides an overview of the goals of each of these tools and shows the first steps to leveraging them in your daily routine.

International PHP Conference 2011

10 Years of PHPUnit

Presentation by Sebastian Bergmann

2011 marks the 10th anniversary of PHPUnit, the de-facto standard for unit testing PHP work. Join Sebastian Bergmann, the tool's creator, in this session for a look at the history of the project, at new features in PHPUnit 3.6, as well as upcoming developments.

PHP Tester's Toolbox

Presentation by Sebastian Bergmann

This presentation provides an overview of the goals of each of these tools and shows the first steps to leveraging them in your daily routine.

Security 202: Are you sure your site is secure?

Presentation by Arne Blankerts

Being the good developer that you are, all the applications you create are being designed with security in mind. So of course you are following all the known best practices, you know you did your job well. You did, didn't you?

In this session we will take a look at various common security myths and why quite many approaches, tutorials and common solutions just don't quite cut it. Find out what your options are to really get the job done and what you might have been missing in your current implementation!

Scalable High-Performance Architectures

Presentation by Stefan Priebsch

Today, large-scale PHP platforms like Facebook demonstrate strikingly that it is quite possible to build scalable, high-performance web applications with PHP. It does not work out to just use an MVC framework as architecture, though.

This session allows a peek into web architectures and technologies that large-scale PHP platforms use, and demonstrates how you can use them in your own projects.

This way or the other way?

Presentation by Stefan Priebsch

Many decisions are required when developing software. If we are not sure which path to choose (which is often), we just guess. How about running an A/B test instead, so we can base our decision on empirical data? Why not continuously run A/B tests to increase conversion rates or sales?

This presentation introduces how to properly do experiment-driven development in PHP.

ZendCon 2011

Beware of the dark side, Luke!

Workshop by Arne Blankerts

Switch sides for a day and attack the demo blackbox application! Learn how attackers gather information, exploit vulnerabilities and hijack servers -- and what to do to stop them.

Design Patterns in Action

Workshop by Stefan Priebsch

Design patterns are proven solutions to common coding problems. You probably even know some design patterns, but can you really apply them in praticse? In this workshop, we will solve some interesting, web-related coding problems using design patterns like Command, State, or Strategy. And while we are at it, we discuss best practices, for example composition over inheritances, single responsibility, and separation of concerns.

No slides will be shown. All code will be written and explained live instead, taking audience questions and feedback into account.

PHP Tester's Toolbox

Presentation by Sebastian Bergmann

This presentation provides an overview of the goals of each of these tools and shows the first steps to leveraging them in your daily routine.

Performing Security Audits

Presentation by Arne Blankerts

To ensure the high quality of your source code, you of course write (unit) tests and do regular code reviews. Judging the state of security though may seem a lot harder than it is -- if you do not know what to look for and where to get started.

This talk will introduce you to security audits, why and how tools can assist a manual review and why a mere scanner based approach does not work.

Change is inevitable (except from a vending machine)

Presentation by Stefan Priebsch

Where did Bob live two years ago? And what was his last email address again? If your application needs to keep track of things that change over time, you must to take a step beyond normal object relations or foreign keys in a database.

This presentation introduces temporal patterns to solve these kinds of problems and shows how to effectively implement them in PHP using the date extension.

We are looking forward to sharing our experience and knowledge with you at these excellent events. See you in October!

Towards Better Code Coverage Metrics in the PHP World

nospam@example.com (Sebastian Bergmann) — Fri, 17 Jun 2011 20:00:00 +0200

Remember that I promised to blog about the requirements planning for more sophisticated support of code coverage metrics in PHP tools that I did with Derick earlier this year? While we met in London in February and Montreal in March to discuss this, both of us were too busy to communicate what we want to do yet.

This blog posting will hopefully shine a light on what it is we are planning.

Current Situation

Code Coverage is a common metric used in software testing. PHPUnit supports this valuable software metric by leveraging the PHP_CodeCoverage component which in turn makes use of Xdebug, an extension to the PHP interpreter. The support for code coverage could, however, be improved even further.

Xdebug currently only supports what is usually referred to as Line Coverage. This software metric measures whether each executable line was executed.

Based on the line coverage information provided by Xdebug, PHP_CodeCoverage also calculates the Function / Method Coverage software metric that measures whether each function or method has been invoked. This software metric is actually implemented in a much stricter way in PHP_CodeCoverage because it only considers a function or method as covered when all of its executable lines are executed at least once during test execution.

The Future

In the future it would be nice to make available more sophisticated code coverage metrics such as Statement Coverage, Branch Coverage, Call Coverage, and Path Coverage to the users of PHPUnit, PHP_CodeCoverage, and Xdebug.

Statement Coverage measures whether each statement is executed (a line of code can contain more than one statement). A mapping from statement to the start and end column in the corresponding line of code is desirable but would require changing PHP's compiler. It is, however, possible to extend Xdebug to report the number executable and executed statements for a line of code.

Branch Coverage measures whether the boolean expression of each control structure evaluated to both TRUE and FALSE during the execution of the test suite. This should be relatively easy to implement based on the information provided by Statement Coverage.

Call Coverage measures whether each function or method call is executed and should be possible to implement in userland (in PHP_CodeCoverage) based on static code analysis and statement coverage.

Path Coverage measures whether each of the possible paths in each function or method has been followed. A path is a unique sequence of branches from the entry of the function or methods to its exit. It should be possible to implement this in userland (in PHP_CodeCoverage) based on static code analysis and branch coverage.

As an alternative to Path Coverage it might make sense to implement Linear Code Sequence and Jump (LCSAJ) Coverage instead. This variation of Path Coverage does not require a flow graph and also avoids its exponential difficulty. It should be possible to implement in userland (in PHP_CodeCoverage) based on static code analysis and branch coverage.

The development of these features will take a lot of effort. It will be a challenge to find time in our schedules to work to tackle these features. But I felt like sharing what we are thinking about with you, the users of our tools, as soon as possible.

Presenting at OSCON 2011

nospam@example.com (Sebastian Bergmann) — Fri, 03 Jun 2011 09:20:00 +0200

This July I am going to present at OSCON in Portland again:

Testing LAMP Applications

Most web applications are changed and adapted quite frequently and quickly. Their environment, for example the size and the behaviour of the user base, are constantly changing. What was sufficient yesterday can be insufficient today. Especially in a web environment it is important to monitor and continuously improve the internal quality not only when developing, but also when maintaining the software.

Packed with in-depth information and step-by-step guidance, this tutorial sets you on a path to create, maintain and extend sustainable software of high quality with PHP. You will learn how to plan, execute and automate tests for the different layers and tiers of a Web application.

Integrate Your PHP Project with Jenkins

Jenkins is the leading open-source continuous integration server. Thanks to its thriving plugin ecosystem, it supports building and testing virtually any project. This session will familiarize the audience with Jenkins and show how it can be leveraged for PHP projects

Reviewing PHP Code

A code review can help detect bugs and keep the code maintainable. In this session, Sebastian Bergmann, a pioneer in the field of quality assurance in PHP projects and creator of various development tools, will introduce the audience to the best practices and available tools to perform code reviews of PHP-based software projects.

os11fos is a discount code that will save you 20% when you register for the conference.

Debugging with Git and PHPUnit

nospam@example.com (Sebastian Bergmann) — Fri, 18 Mar 2011 12:00:00 +0100

git bisect can be used to find the change that introduced a bug. It does so by performing a binary search on the list of commits between a known good and a known bad state of the repository. A tool such as PHPUnit can be invoked at each step of the binary search to check whether or not the current state is broken.

Let us assume that the unit tests for our project fail at the current HEAD of the master branch:

sb@ubuntu bankaccount % ant
Buildfile: /home/sb/bankaccount/build.xml

phpunit:
     [exec] PHPUnit 3.5.13 by Sebastian Bergmann.
     [exec] 
     [exec] FSSSS
     [exec] 
     [exec] Time: 0 seconds, Memory: 4.50Mb
     [exec] 
     [exec] There was 1 failure:
     [exec] 
     [exec] 1) BankAccountTest::testBalanceIsInitiallyZero
     [exec] Failed asserting that <integer:1> matches expected <integer:0>.
     [exec] 
     [exec] /home/sb/bankaccount/tests/BankAccountTest.php:7
     [exec] 
     [exec] FAILURES!
     [exec] Tests: 1, Assertions: 1, Failures: 1, Skipped: 4.

BUILD FAILED

We know that the code worked when we initially imported it. So we need to look up the hash of the initial commit:

sb@ubuntu bankaccount % git log --pretty=oneline
3e83825c0695bcfc1ea38880352b3449f578e4f0 Do not run PHPUnit in verbose mode by default.
48b683a02c54e732a8c3045b21c4f9183343dea8 Remove @covers annotations.
d54ba9eb910ce9fe9feafa6b9dbd2675ce43227a Break something.
e0c72d7409e461833ce1842e994de4148aa68da4 Remove comment.
75c5d82a31c768d28847d1908cfaa7d15fece4f7 Initial import.

Now we can tell Git that the initial commit was good and that the current state is bad:

sb@ubuntu bankaccount % git bisect start
sb@ubuntu bankaccount % git bisect bad
sb@ubuntu bankaccount % git bisect good 75c5d82a31c768d28847d1908cfaa7d15fece4f7
Bisecting: 1 revision left to test after this (roughly 1 step)
[d54ba9eb910ce9fe9feafa6b9dbd2675ce43227a] Break something.

Next up is actually performing the binary search operation. At each step we use Apache Ant to invoke PHPUnit. The commit will be considered good when all tests pass and bad otherwise.

sb@ubuntu bankaccount % git bisect run ant -q
running ant -q
BUILD FAILED

Bisecting: 0 revisions left to test after this (roughly 0 steps)
[e0c72d7409e461833ce1842e994de4148aa68da4] Remove comment.

running ant -q
BUILD SUCCESSFUL

d54ba9eb910ce9fe9feafa6b9dbd2675ce43227a is the first bad commit

commit d54ba9eb910ce9fe9feafa6b9dbd2675ce43227a
Author: Sebastian Bergmann 
Date:   Thu Mar 17 10:26:56 2011 +0100

    Break something.

bisect run success

And this is how you debug using Git and PHPUnit

Visualization of PHPUnit Development

nospam@example.com (Sebastian Bergmann) — Wed, 16 Mar 2011 07:00:00 +0100

According to svn.php.net, I committed the first PHPUnit code to cvs.php.net on November 27th 2001 and the first release, PHPUnit 0.1, was made on December 1st 2001.

I started using svn.phpunit.de for the development of PHPUnit on June 29th 2006. I did not import any history from CVS into Subversion.

On December 26th 2009, I moved the development of PHPUnit from svn.phpunit.de to GitHub. I imported the history from Subversion into Git. As you can see in the video, moving to GitHub lead to an increased number of contributions to PHPUnit.

On Sponsored Open Source Development

nospam@example.com (Sebastian Bergmann) — Thu, 17 Feb 2011 13:50:00 +0100

This campaign on Pledgie is an experiment by Derick Rethans to find out whether or not it is feasible to expedite the work on feature requests in Open Source projects such as Xdebug. Since I more or less gave Derick the idea for this experiment, I will try to shine a light on our reasoning for this approach in this blog posting.

For quite some time now, Derick and I occasionally discuss how the collection of code coverage information in Xdebug can be improved so that PHP_CodeCoverage can provide more useful information when you are running your unit tests using PHPUnit, for instance.

At the moment, Xdebug only supports Line Coverage which means it can only tell us whether or not a particular line of code was executed or not. Since a line of code can contain more than one statement, the implementation of Statement Coverage in Xdebug would tell us whether just one statement in a line is executed (which would already count towards Line Coverage) or whether all of its statements are executed at least once while running the tests. Other code coverage metrics that are desirable include Branch Coverage, Path Coverage, and Call Coverage -- and we would like to have them supported by Xdebug and PHP_CodeCoverage as well.

Implementing the data collection for these more sophisticated code coverage metrics in Xdebug and adding support for them in PHP_CodeCoverage is not a small task. And while both Derick and I live and breathe Open Source and like to hack on code things like work and private life do interfere with the development of our Open Source software projects. So with development efforts like this we can either wait for the time when "we have nothing else to do" or try to find support from the people that use the development tools we create on a daily basis that allows to work on new features for said tools sooner rather than later. And although it would be awesome if a single company would approach us with "Hey, we would really like to pay the whole development of these more sophisticated code coverage metrics in Xdebug and PHP_CodeCoverage!" we realise that this is highly unlikely. A platform such as Pledgie, where many individuals can pledge small (and not so small :-) amounts of money could be the solution we are looking for.

Derick's first campain for Xdebug is about a bugfix. And at first glance it might seem rather odd to "demand" money for fixing a bug. As is the case with most complex issues, having a closer look usually clears things up. So what has happened? Xdebug's profiling functionality can dump its information in a format that can be processed and visualized with a tool called KCacheGrind. At the time when Derick implemented this functionality, the data file format used by KCacheGrind was not (well) documented so he had to reverse engineer it. In that process he overlooked the fact that KCacheGrind expects information that he did not provide (namely the "cfl=" lines that tell KCacheGrind the target of a function or method call). Versions of KCacheGrind prior to the current one used a too relaxed merging of symbols and so it appeared that there was nothing wrong with the data written by Xdebug. Current versions of KCacheGrind, however, are more strict and expect the aforementioned "cfl=" lines. Without them the visualization of Xdebug profiling information is useless. I noticed this last week and talked to Derick about it. Apparently others had experienced the same issue but he had not had any time yet to investigate it because he is, just like I am, too busy with paid work. Only half-jokingly I told him on Twitter to try Pledgie for this and promised him to pledge money for this if he did (I really need KCacheGrind to work for profiling PHP code). So now you know why we are experimenting with Pledgie at the moment.

With regard to the more sophisticated code coverage metrics that I mentioned in this post our plan is to gather requirements and try to estimate the amount of time needed to implement what we want when I am in London next week. We will keep you posted!

PHP Project Wizard

nospam@example.com (Sebastian Bergmann) — Sun, 06 Feb 2011 13:00:00 +0100

Hot on the heels of the Template for Jenkins Jobs for PHP Projects comes my next new Open Source project: the PHP Project Wizard (PPW).

The PHP Project Wizard (PPW) is a commandline tool that can be used to generate the scripts and configuration files necessary for the build automation of a PHP project. Given the location of a project's directories with sourcecode and tests as well as the project's name, the PHP Project Wizard generates scripts and configuration files necessary for build automation using Apache Ant.

ppw --source src \ --tests tests \ --name myproject PHP Project Wizard (PPW) 1.0.1 by Sebastian Bergmann. Wrote build script for Apache Ant to build.xml Wrote build configuration for Apache Ant to build.properties Wrote configuration for PHPUnit to phpunit.xml.dist

The artifacts produced by the build are exactly what the template for Jenkins jobs for PHP projects expects.

Template for Jenkins Jobs for PHP Projects

nospam@example.com (Sebastian Bergmann) — Fri, 04 Feb 2011 09:30:00 +0100

Jenkins is the leading open-source continuous integration server. Thanks to its thriving plugin ecosystem, it supports building and testing virtually any project. The goal of my newest open-source project, the Template for Jenkins Jobs for PHP Projects, is to provide a standard template for Jenkins jobs for PHP projects.

By the way: thePHP.cc offers consulting and training that set you on a path to create, maintain and extend sustainable software of high quality with PHP and leverage Jenkins to monitor the various aspects of software quality.

Sebastian Bergmann - PHP

PHP Summit in London

Update PHP: Leverage New Features and Technologies

Workshop with Sebastian Bergmann

Unclean PHP: Identify, Refactor, Avoid

Workshop with Sebastian Bergmann

Best Practices: From the Real World for the Real World

Workshop with Arne Blankerts

Safely Prepared for Errors

Workshop with Arne Blankerts

Object-Oriented Progamming (OOP) in PHP I: Fundamentals

Workshop with Stefan Priebsch

Object-Oriented Progamming (OOP) in PHP II: Advanced Topics

Workshop with Stefan Priebsch

Testing PHP Application: Fundamentals

Workshop with Sebastian Bergmann

Testing PHP Applications: Advanced Topics

Workshop with Sebastian Bergmann

Insider's Tip XML: Applications the Smart Way

Workshop with Arne Blankerts

Tuning for Web Applications

Workshop with Arne Blankerts

Design Patterns I: The Most Important Standards

Workshop with Stefan Priebsch

Design Patterns II: Integrating Sophisticated Patterns

Workshop with Stefan Priebsch

Modern Version Control with Git

Workshop with Sebastian Bergmann

Continuous Integration with Jenkins

Workshop with Sebastian Bergmann

It is best to expect the worst!

Workshop with Arne Blankerts

Attack! What makes attacks on the Web successful

Workshop with Arne Blankerts

Framework: Basics in Three Hours

Workshop with Stefan Priebsch

Why the Tower of Pisa is Leaning

Workshop with Stefan Priebsch

PHP Summit in München

Update PHP: Neue Features und Technologien nutzen

Workshop von Sebastian Bergmann

Weg mit Strubbelcode: identifizieren  verbessern  vermeiden

Workshop von Sebastian Bergmann

Best Practices  aus dem Alltag für den Alltag

Workshop von Arne Blankerts

Auf Fehler sicher vorbereitet sein

Workshop von Arne Blankerts

Objektorientierte Programmierung (OOP) in PHP I: Basiswissen

Workshop von Stefan Priebsch

Objektorientierte Programmierung (OOP) in PHP II: Aufbauwissen

Workshop von Stefan Priebsch

PHP-Anwendungen testen: Basiswissen

Workshop von Sebastian Bergmann

PHP-Anwendungen testen: Aufbauwissen

Workshop von Sebastian Bergmann

Geheimtipp XML: Die smarte Art der Anwendung

Workshop von Arne Blankerts

Neu: Tuning für Web-Anwendungen

Workshop von Arne Blankerts

Entwurfsmuster I: Die wichtigsten Standards

Workshop von Stefan Priebsch

Entwurfsmuster II: Integration anspruchsvoller Patterns

Workshop von Stefan Priebsch

Moderne Versionskontrolle mit Git

Workshop von Sebastian Bergmann

Kontinuierliche Integration mit Jenkins

Workshop von Sebastian Bergmann

Am besten mit dem Schlimmsten rechnen!

Workshop von Arne Blankerts

Attacke! Was Angriffe im Web erfolgreich macht

Workshop von Arne Blankerts

Framework: Basics in drei Stunden

Workshop von Stefan Priebsch

Warum der Turm in Pisa schief steht

Workshop von Stefan Priebsch

A Tool's Tale

Static Analysis with HipHop for PHP

PHP Training in Montréal

Using CLANG/scan-build for Static Analysis of the PHP Interpreter

Testable Code: Rockstar Edition

Weg mit Strubbelcode: identifizieren verbessern vermeiden

Best Practices aus dem Alltag für den Alltag