Talks

Cal Evans
A live coding demonstration using Flash Builder 4 Anyone can show you slides with code on them. It takes real guts to get up in front of an audience and code live. In this session, Cal Evans will do just that. Using only Flash Builder 4 and the other array of tools on his laptop, Cal will build a working Flash Builder 4 application.
Come laugh along with the rest of the audience at Cal's horrific typing and spelling skills as he leads you though the steps necessary to write code with Flash Builder 4. Beware though, along the way he may just spark your interest in this tool and give you dangerous ideas about projects you want to build.

Chris Shiflett
Security is more than filtering input and escaping output (FIEO), and it's more than cross-site scripting (XSS) and cross-site request forgeries (CSRF). Security isn't even always black and white. In order to create a more secure user experience, we need to understand how people think. Perception is as important as reality, and meeting user expectations is a fundamental of good security. In this multifarious talk, I'll explore topics such as change blindness and ambient signifiers, and I'll show some real-world examples that demonstrate the profound impact human behavior can have on security.

David Soria Parra
Besides OpenSource projects like the Linux Kernel, OpenJDK or Perl, companies increasingly use distributed version control systems like Git and Mercurial. Their unique features makes new and modern workflows possible, which are particularly useful in agil development.

The talk gives a introduction to the advanced features of Git and the fundamental concepts of modern distributed version control systems.

David Zuelke
There has been a lot of buzz lately about the NoSQL movement in general and CouchDB in particular. For people who are used to relational databases, a lot of CouchDB's limitations look like severe disadvantages; these constraints however can also be great opportunities. This talk will give an overview of CouchDB and then focus on embracing the system's constraints to build better products.

Derick Rethans
This session explain a certain set of design issues for library code that either is often extended, or created with extending and inheritance in mind. There are many ways how a library can be designed to make it both easier to test, as well as for external developers to consume and use. This presentation provides techniques for doing so.

Elizabeth Naramore
Technical debt is something that most project teams or independent developers have to deal with - we take shortcuts to push out releases, we don't focus on quality, deadlines need to be met, quick fixes slowly become the standard. Whatever the reason, if we don't manage our technical debt (not unlike financial debt), before too long our applications are technically bankrupt, and we are forced to completely refactor and start anew.

In this talk, we will discuss what technical debt is, when it is acceptable and when it isn't, and strategies for effectively managing it, both on an independent and team level. We'll talk about how it affects the entire team and how to work through minimizing it, as well as working effectively as a team to address it.

Elizabeth Naramore
If you've had an idea for writing a blog post or article, but you're not sure where to start, this talk is for you! Maybe you've had difficulty effectively documenting your code, or communicating your ideas to non-techies. This talk will help you, too! In this fun and informative session, we'll discuss the basics of writing and clear communication through the written word. We'll also talk about strategies for keeping your writing interesting and informative at the same time. Finally, we'll discuss resources for improving your writing skills in the future.

Harrie Verveer
We've all read the textbooks and are using version control systems for our code, but our databases are left out in the cold. Every team has their own workaround, ranging from patch files to SQL snippets in the bugtracker, but none is really robust. Unfortunately there is no silver bullet, but there are several tools and best practices that can help you to make your life easier. This talk shows several approaches that can help you to overcome this problem and to control database structure changes in a more sophisticated way.

Helgi Thormar Thobjoernsson
Anyone that has written a Content Management System or a blog system, has quickly realised that people will want to extend the functionality of the application and thus the developer has to embark on a journey to write a plugin system with everything that comes with that.

One of the biggest parts of any plugin system is the part that deals with discovery, installation, upgrading, dependency handling, infrastructure and other equally boring things. An essential part of any plugin system yet everyone dreads writing it, and few actually take on the task of writing it.

With Pyrus (the new PEAR installer) these tasks will not only be easy to do but also a joy. By embedding Pyrus in your application with its lavish new APIs you can use a tried and tested solution that hundred of thousands of people use every day on their command line, but you will be able to provide it right IN your tool, in your admin area, properly integrated with the layout and dictating the flow of the processes so it fits the ideologies of your software. Learn how to provide your users with fantastic experience, at the low price of using in the Pyrus installer in your application instead of trying to write your own solution.

Ian Barber
Despite being a key method of navigation on many sites, search functionality often gets the short end of the stick in development, either by handing the job over to Google or just enabling full text search on the appropriate column in the database. In this talk we will look at how full text search actually works, how to integrate local text search engines into your PHP application, and how it's possible to actually provide better and more relevant results than Google itself, at least for your own site.

Ilia Alshanetsky
APC and Memcache both provide effective mechanism for caching data within PHP applications to improve performance and latency. This talk will cover when to use both of these tools to get the most of your apps and which workflows better suit each tool.

Ilia Alshanetsky
One of the things that many people want to have is fast code as it allows handling of more data/clients with less resources, saving money and improving your overall efficiencies. However, premature optimization can often result in broken code, enormous amount of wasted time and missed deadlines. This talk will not only explain the common errors, but also offer easy performance solutions.

Johannes Schlüter
PHP developers usually don't have to care about the inner workings of PHP and the Zend Engine as it simply works. This presentation will present some of the inner workings, like teaching the truth about references. Additionally it will present basics of PHP's opcode, the internal representation of a script, and it's consequences for opcode caching, autoloading and other related issues.

Kevlin Henney
Programmers have a lot on their minds. Programming languages, programming techniques, development environments, coding style, tools, development process, deadlines, meetings, software architecture, design patterns, team dynamics, code, requirements, bugs, code quality. And more. A lot.

The 97 Things Every Programmer Should Know project has collected together the wisdom of many contributors to offer a distilled snapshot of what every programmer should know. This session draws from this collection to present some highlights and useful advice.

Lorenzo Alberton
Having invested time and energy into your application,
nothing could be more exciting than seeing it gain popularity, and seeing your user base grow. However the success of your application could also turn into your worst nightmare! What if the site cannot cope with the load and collapses under its own weight?

The ability to grow (and shrink) according to the needs and the available resources is an essential part of designing applications. In this talk we'll cover the fundamental elements of scalability, including aspects involving people, processes and technology. With sound and proven principles and some advice on how to shape your organisation, set the right processes and design your application, this session is a must-see for developers and technical leads alike.

Marcus Deglos
Googlemaps, Multimap, Ordnance Survey...if you simply want to embed a map, there are plenty of APIs out there. But what if you want to build the next mapping application?

This intro explains the basics of Geographical Information Systems, how GIS data can be represented in PHP, and the libraries for manipulating and analysing GIS datasets.

Matthew Weier O'Phinney
Zend Framework offers excellent facilities for creating RESTful web services via the Zend_Rest_Route component. Couple this with its ContextSwitch action helper, and it's trivially easy to provide RESTful endpoints for a variety of contextual endpoints, including XML and JSON.

In this session, we'll look closely at the mechanics and implications of Zend_Rest_Route, how and when to do content-type negotiation, and several approaches to making the logic in your controller re-usable across content types. Additionally, we'll look at how such a RESTful service might be consumed by client-side scripting via Dojo's JsonRestStore -- providing a real-world case for implenting REST in your web application.

Matthew Weier O'Phinney
Until recently, Relational Databases have been the rage... but now there's a new kid on the block: the NoSQL database. NoSQL databases turn the conventions we've all learned on their heads: data normalization, pivot tables, schemas, and more. Instead of storing metadata and relations across tables, we can create custom schemas per record -- offering incredible flexibility and reducing the number of queries required to get at exactly the information we need. Additionally, another movement has been taking development practices by storm: the idea of using Plain Old PHP Objects as domain entities. By not tying the domain objects directly to the data store backend, developers gain both testability and flexibility. No longer is the domain model tied to an RDBMS solution, allowing usage of NoSQL solutions -- which in many ways are more suited to domain models than their RDBMS counter parts. In this talk, we'll look at some of the advantages and disadvantages of NoSQL databases, as well as some examples of applications that could benefit from the new paradigms they offer.

Melanie Rhianna Lewis
A web service is an API provided by a site that allows a remote application to access data and use functionality without having to 'act like a web browser'. Consumer devices, such as a smart phone, set top box or games console, often do not have a form factor that allows the easy use of an interactive web site but do allow the download of custom applications which use web services provided by such sites.

The talk will describe how a web service targeted at consumer devices can be implemented. It will look at the different methods of calling remote functionality such as SOAP, XML-RPC, JSON and restful services. It will also consider the limitations of consumer devices, memory restrictions, communications bandwidth restrictions, and so on that have to be considered when designing a web service aimed at consumer devices. Finally it will have a brief look at how to make a service secure.

Michael Maclean
Generating graphics on-the-fly in PHP applications is a common requirement. Cairo, from the Freedesktop project, is a fast 2D vector graphics library with outputs to many different devices. It is already used by many big-name Open Source projects such as GNOME and Mozilla Firefox. The PECL Cairo extension for PHP 5.2 and above provides an easy-to-use interface and to Cairo useful for generating images, SVGs and PDFs. This talk will demonstrate how to use its features in common situations, and compare it with other image libraries such as GD. Major points to be presented:

• Overview of the Cairo library
• Basics of using PECL/Cairo for drawing images
• SVG, PDF and Postscript
• Text handling
• Integration with existing PHP frameworks and libraries
• Examples

Rob Allen
This talk will concentrate on the various strategies you can use to ensure that developing and releasing new features to a live website is stress-free. Firstly we will look at how organising your source code into branches can provide confidence and allow for features to go-live in any order. We will the consider the mechanics of deploying a new version of the website to the server, ensuring that we can repeat the process the same way every time. Finally we will look at how to roll back a deployment easily and quickly when something goes wrong.

Rob Allen
Zend_Form is a powerful component than can simplify form handling within your web application. Find out in this session how to make Zend_Form render and validate your form elements and ease the pain of forms on web pages.

We will look at configuration, data filters & validation and error handling. One particularly tricky area is the use of the decorator pattern to control the generated HTML when rendering the form. This session will therefore also take a detailed look at this especially powerful functionality and show how to ensure that your forms are rendered as desired.

Brian Swan
Following the recent investment of time and effort by both Microsoft and the core PHP developers, Windows with PHP 5.3 is a good platform choice. This introductory session will take a look at the parts of this ecosystem, walking through the installation of PHP on Windows and showing how to use the FastCGI component of IIS and the URL rewrite module. With SQL Server accessed SqlSrv and the WinCache extension for speed, we can see that deployment on Windows is a competitive option for PHP developers.

Sam de Freyssinet
The ambition of web applications has only been impeded by the economies of scaling. The Hierarchical-MVC pattern enables ambitious applications to be designed without worrying about the dreaded 'S' word.

This talk will provide an overview of how to build applications that scale vertically and horizontally effortlessly when using the HMVC pattern. We will examine how the request object can provide a cost effective way to create an application of services. Then we will see how interrogation of the request object can reduce the size of the codebase across the entire application.

Scott MacVicar
HipHop transforms PHP source code into highly optimized C++ and then compiles it using g++. It allows developers to continue writing complex logical directly with PHP but leverages the speed benefits of C++. HipHop is more than just a theoretical exercise and currently powers the majority of Facebook servers. This session will cover using HipHop and some of the code changes required to use it.

Sebastian Bergmann
A code review can help detect bugs and keep the code maintainable. It can be performed internally, which means that software developers of the same team review each other's code. It can also be performed by a person external to the team that develops the software.

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.

Sebastian Bergmann
Even if you have not played the game Portal" you might have come across the phrase "The cake is a lie". According to the Urban Dictionary, it roughly translates to "your promised reward is merely a fictitious motivator".

Scaffolding, the meta-programming method of building software applications, promises easier development and a faster time-to-market. But the "code generation bliss" can lead to problems later on, for instance with regard to maintainability and scalability. This sessions takes a sceptical look at frameworks such as CakePHP and Symfony."

Sebastian Schuermann
PHP is a very nice language, but it's design has some shortcomings when it comes to a large number of http requests at the same time. Every access to a ressource, like for example a database or a filesystem makes your server wait for a result and blocks CPU cycles/RAM that could be used for other things.

• Lifecycle of a apache+php request for starters and why it's not perfect
• Shortcomings of current php caching methods
• The http Status code 202 Accepted
• Nodejs architecture for starters
• Implementation of a ajax proxy to a php webservice that will even work when under heavy load

The nodejs webserver can fix this with it's asycronous way to handle requests and working with externals sources of data.

Stephan Hochdoerfer
The Dependency Injection (DI) pattern is getting more and more attention in the PHP world due to it's code simplification effects. It focuses on the complete separation of object instantiation and dependency tracking from the business logic resulting in a loosely coupled system. In addition to that the resulting code is a lot easier to test since the classes are no longer responsible for instantiating their own dependencies. This session will introduce the basics of the DI pattern to the audience in addition to share real world experience of DI in several customer projects in the last four years.

Stephan Hochdoerfer
Testing software applications with the help of unit testing facilities is an widely-adopted standard in the software development industry today. Even the PHP community provides such tools to automate the testing of PHP applications. Unfortunately there exist legacy applications that are not testable by their internal design. Testing an single component of such an application in isolation is not possible in those cases due to their dependencies on other components. This often leads to the point of manual testing which is cost-intense and error-prone. In the first part of the session it is shown how the dynamic nature of PHP itself can be used to manipulate existing dependencies to be able to test a single component of the application on its own. In the second part of the session an additional layer of abstraction is introduced. By using that layer it is shown how to transform components of the original source code into testable code fragments.

Thijs Feryn
Most PHP talks are given from the point of view of people who work on a project internally. These people are mostly developers, designers, project managers, QA's and there's even an occasional business man who shares his opinion on PHP. I would like to talk about PHP through the eyes of a hoster. Eventually a project is going to get hosted on the internet and in a lot of cases an external webhosting company will take care of that. As the support manager and open source evangelist of a large hosting company, I will bring you a story about how a hoster experiences the wonderful world of PHP, about what can go wrong for customers and about how a webhoster can solve these issues.

This tale describes everyday situations in 45 minutes where PHP is a blessing as well as a burden. This includes:

• Ensuring harmony on a shared server
• Migrating applications from other servers
• Dealing with hacked websites
• Boosting performance
• Teaching customers how to make their apps scale
• Solving code issues serverwise
• Securing applications
• Patching, debugging & profiling
• ...

Thorsten Rinne
Every PHP developer knows about Scrum, eXtreme Programming and Crystal Clear. But do you know how these methods fit in agile software development to release the software on time? The certified scrum master Thorsten Rinne will present a customer project where all these methods were used in the hard daily work. He will present short indtroductions for each method and will talk about pitfalls to the audience.