Dutch PHP Conference

We're moving from a web of pages to a web of people and devices. Those people and devices have identities associated with them. In this talk I'm going to show how identity is currently propagated from devices to browsers to sites and apps. I'll also talk about the new kinds of devices that are turning up on the market, how they're sing the web, how they're changing the web and what we can do about it.

I recently released three iPhone apps: GameCoach for Letterpress, Ruzzle and WordOn. These apps were an exercise in game strategy, character recognition and artificial 'intelligence'. To make these apps possible, I made a cms system in Php that acts as a game analyzer and game management tool. It uses imagick and a number of other tools to collect, analyze and process game screenshots, extract relevant information and build up a binary tree based character recognition algorithm tailored to a specific game. In this session I will demonstrate some of the leanings of this project and show how php helped me build these apps.

Managing dependencies and third-party code in PHP applications is a daily challenge, keeping everyone on the same versions during development and at deploy time a struggle. Meet Composer a tool designed to help you maintain a consistent set of dependencies as well as share and discover new libraries. Let's see how you can use this tool in your Applications and Libraries to wrangle your dependencies with a simple json configuration file and a command line interface.

With the rise of dependency injection (DI) containers, which may or may not also be service locators, it is now very easy to keep track of all the dependencies of your classes and to switch between implementations. The temptation of using the new operator has since become much smaller. Still, all the options of the containers and locators, the syntax of the service definitions and lack of knowledge about design patterns related to dependency injection have resulted in some bad dependency injection design practices.

In this talk I will describe a couple of very recognizable and also very well fixable Dependency Injection Smells. After showing a code fragment which contains one of these DI smells, I will continue to work out different scenarios in which the situation gets out of hand and the smell becomes too bad. A solution then comes from existing design patterns and some general design principles.

Altough every application needs to be deployed in some way, there's still a lot to learn about it. This talk will show how to create a bulletproof deployment system, covering the following topics:
- common deployment problems
- rolling back
- (doctrine) database migrations
- zero downtime
- git branching strategy
- chef integration for dependency management
- capifony for easy symfony deployment
- multi environment configuration
All will be illustrated with a step by step deployment of a symfony application, using capistrano with capifony.

Where does design fit in agile projects? What is refactoring and what isn't refactoring? What is the relationship between design and refactoring, and design and architecture? In this talk we will clarify these and other questions around emergent design and how a TDD/BDD tool like phpspec can help you with the process. We will look into how phpspec helps uncover smelly code and point in the direction of refactoring techniques to guide the design of flexible, testable and easy to extend object oriented PHP code – enabling developers to focus on what’s more valuable for the customer at all times and re-steer the direction of the product.

Exploring some of the possibilities of how to handle big data in PHP. Although PHP may not traditionally be seen as a technology directly interacting with huge datasets, the fact is that even the data consumed on even the most modest webste is getting larger and larger.  Code written a few years ago can easily crawl to a stand-still with datasets growing at fast rates year-after-year. The idea is to get people to stop thinking about different ways to tackle data growth both in web applications and other off-line php uses. Get the most out of PHP by using it less, but using it smartly - let the database do what its even better at - handle data.

The session is split into three sections covering as much as time permits

(1) Get more out of your existing relational Database and flat files (2) Explore other database solutions and break away from MySQL (3) Look at some of the other options for big data such as cloud-based storage services

Some Goodies We'll cover as time permits:

• Use a fulltext table Then use fulltext queries to isolate candidates for xpath functions to further analyze.
• Step away from Relational DB and have a look at the same data imported into MongoDB and why this might be better.
• Can't decide between relational and document-oriented or want to get through a proof-of-concept test fast? Lets look at the Akiban server and see how this might help.
• Data services and distributed systems for your really big data
• Smart use of PHP - No queries inside of loops when possible. Re-write as joins or subqueries or even run your loop to build a much more efficient query at the end outside of the loop.
• Hybrid data manipulation - do some queries and dance around your data with array_key_intersect and lots of arrays that are references.
• Special consideration in MySQLViews/merge tables/partitioning to get to your data faster.
• All results at once? No Way! Explore ways to get to your data without taking the server down
• A Big Flat File is OK sometimes- a shard-based approach for looking through your data if its not in a database.
• As much as possible, samples will be based on a fun set of data - the raw data from the Shuttle Radar Topography Mission

Tools can be a major part of a project - when done correctly. During this talk we'll look at the power of managing all environments with a small toolbox. With a proper toolbox, a new development environment is never more then a few steps away and deploys are done with one command. It can require a shift in mindset as well as some investment to get everything up and running, however it's all for the best. Why? We can now ensure that developers no longer need to keep check on what is where on which environment; they can focus on doing what they do best: write awesome code for fantastic projects. 

In most cases, the best place to get some data is right there in some website. The data owner might not have an API and is not really interested in providing you with data in any other form. So you are stuck trying to figure out how to scrape that data and makes sense of it…

This is where web scraping comes in - building small applications which understand the semantics of some websites and can figure out how to extract and categorize information, eventually with even some machine learning. This talk goes through the basics of web scraping and teaches you how you could build them and not get IP-banned by every site out there. 

I am not an expert. I am a noob. I will be sharing the lessons I've learned from a career of being in a constant state of noobage. From learning PHP in 1998 to angel investing in 2013. Regardless of where you are in your career, there will be something for everyone in this talk. 

There comes a point in time with a website when eventually need to do something in the background. There are always cron jobs, but eventually those either don’t scale well, or are not responsive enough. Learn about how to help your website efficiently scale by using workers. We’ll discuss the fundamental theory behind workers and how to easily implement them. We’ll learn about several different technologies to help manage workers such as Gearman, Supervisord, Redis, and others. We’ll show a live demo of PHP workers performing tasks and you’ll leave with sound understanding of how to implement workers in your own application.

Although tools like Varnish can improve performance and scalability for static sites, when user-specific content is needed, a hit to the PHP/Ruby/Python/. Net backend is still required, causing scalability issues. We'll look at a brand-new Nginx module which implements an ultra-fast and scalable solution to this problem, changing the way developers think about designing sites with user-specific content.

We'll go into how the module works and show performance and scalability differences between existing setups and setups with this new tool..

PHP is a powerful language with tons of great frameworks geared at rapid web development, but have you ever wondered what it's like to work in a different language?

This talk introduces you to Django, the Python web framework written for perfectionists with deadlines. When we're finished, you'll have a good idea of how Django and Python work and understand where they might fit into your existing development toolbox. More importantly, you'll see how another ecosystem handles their tooling and learn a few tricks that you can apply to your existing tools, regardless of language.

Choose the red pill. LISP is a very old family of functional languages. It is minimalistic in syntax, yet extremely powerful. This talk will show you a different way of thinking about programs, how to solve problems by using recursion and how to extend the language through macros. It will bend your mind and take you down the rabbit hole.

One of the highly anticipated new features of the upcoming Zend Framework 2.0 release is the introduction of an all new and powerful approach to modules. This new module system has been designed with flexibility, simplicity, performance, and re-usability in mind.

Modules in ZF2 can contain just about anything: PHP code, including MVC functionality; library code; view scripts; and/or public assets such as images, CSS, and JavaScript. With compelling features such native, best-in-class Phar packaging support and event-driven design, the possibilities are truly endless. Join Evan Coury, the author of the new ZF2 module system, as he explains everything ZF2 modules have to offer.

PHP is a high-level language and provides a host of useful libraries and abstractions. Most of the time you can just get away with sort() and in_array() and everything will be fine. However, that's not why we became developers! Algorithms and data structures are fascinating - and an understanding of those low-level concepts will help make you more effective with the high-level ones. We'll look at a variety of algorithms to find out how they work, where they're used, and how they can affect the code you're writing today.

PHP 5.5 is here! This talk will show you what new features we added in PHP5.5. We'll then talk about Generators, new password hashing API, finally keword, engine optimisation (performance)...

Also, we'll see what new functions/methods has been added in Core or extensions as well as what's been deprecated and the backward compatibility breaks. This talk is all you need to know about the new version of the language.

Do you know what is happening in your web application right now, this second, how many requests, logins, exceptions you have, how many and what data your users are generating and what the click through rate of each of your registration step is? Or do you know exactly which exception with which stack trace caused the error your users are seeing? If not, this talk will show how you can easily measure and log everything that happens in your application with the help of open source tools, such as Graphite, StatsD, Graylog2 and Logstash, without influencing your production environment.

HTTP is no longer simply powering browsers talking to servers sending static pages of HTML. HTTP is carrying HTML to dumb browsers, JSON back to single-page apps or mobile apps, and is now pushing data to clients of all stripes. This talk introduces you to architect your infrastructure in a way to make sure that you can meet the needs of tomorrow.

Nginx is a web server that packs a lot of punch in a small package. We will explore useful built in debug tools, powerful load balancing, reserve caching mechanisms and how to augment Nginx by loading in additional modules.

We will explore how to make Nginx talk directly to Memcached / Redis (perfect for APIs, without hitting your application), proxy functionality, improved headers manipulation, Lua in the config and the ability to query MySQL / Postgres among other things.

This is only the tip of the iceberg. I will take you on a journey to explore the hidden corners of Nginx!

PHP is one of the most popular open source programming languages in the world. It powers some of the highest traffic sites in the world, and at the same time it powers some of the lowest traffic sites in the world. But have you ever wondered how it works under the hood? Have you been overwelmed by the thought of looking at the C code that runs PHP? Well, this talk is for you!

We're going to explore how PHP works under the hood, by looking at a PHP implementation of it: PHPPHP! Have you ever wondered what an OPCODE Cache is really doing? Have you ever wondered what a T_PAAMAYIM_NEKUDOTAYIM is? Have you ever wondered why an interpreted languages has a compiler? We'll explore all of these topics, and more! And the best part of it all? You don't need to know C to understand the details! Using PHPPHP, we can explore the language details in a high level language, where things like memory management don't get in the way of the real content. If you've ever wanted to know how PHP works, this is the talk for you!

In a world full of scalability challenges, a reverse caching proxy has become an essential tool to protect your backend servers. This talk is dedicated to that and compares Varnish to Nginx as the 2 tools for the job. We'll be talking about setting the up, playing around with config, making them serve cached PHP content and do some advanced tricks such as ESI.

While there are several popular configuration management tools such as puppet and chef, there is a new kid on the block: Salt. In this presentation we’ll learn about how salt uniquely approaches remote execution and configuration management and just how fast it is. We’ll show you how to get started up in minutes and easily manage multiple servers. We’ll discuss some of the differences between salt and others like puppet and chef. Finally, time permitting, we’ll discuss how to write custom modules to extend salt much easier than others.

So come see why Salt is one of the fastest growing projects on GitHub, and why small startups and even large corporations are making the switch to salt.

You've seen all the Getting started with Sass & Compass talks. Sure, the parent reference and sprites are awesome, but how to use that to tackle real-life problems? Let's take a look at advanced uses, such as the benefits of nested lists, retina sprites, using Sass to code for performance and more.

To be RESTful or not to be RESTful, that seems to be the question that occupies the minds of API developers these days. In this talk we will look at an approach to API design that I have been practicing and refining for the past couple of years. We will look at what Scenario Driven Design means, when it is useful, and what the advantages and disadvantages are, when comparing this design approach with other API design methodologies. We will also look at ways to implement a Scenario Driven Design in PHP. 

Setting up an online shop is a relatively trivial task these days. Pick your application, adjust some templates, sign payment provider contracts, make sure your supply chain is in order, and launch. But once you decide to aim higher and start airing commercials, on TV, during prime time hours, then regular off-the-shelf software will not cope with the flood of incoming requests. That's when it is time to build something a little more durable, without a single point of failure, serving pages in under a hundred milliseconds, unfazed by extreme concurrency, and powered by Symfony2. This is a talk about lessons learned and missions accomplished.

Symfony2 certification will be available at the end of the Tutorial Day. Any attendee with a DPC ticket can register but an additional exam voucher is required. If you're interested in taking the exam, please check the box in the register form and we'll send you a mail with details about purchasing the voucher from Sensio Labs.

As experienced developers we're regularly told that very few API's out there are really RESTful, and sometimes we're even told why and how they could be. But what is the process of actually designing an API that uses hypermedia, and what is hypermedia anyway?

This talk takes the listener through the process of designing an API structure up front that uses hypermedia at it's core over HTTP, what considerations do you need when selecting a media type to represent your resource and what is out there to help you document it for others to use. This session is recommended for architects and developers alike and will give a good grounding in writing excellent, self-explanatory Hypermedia APIs.

Earlier this year Oracle released MySQL 5.6. In this session we will look at recent changes in PHP and new MySQL PECL extensions as well as the new version of MySQL.

What is an object Proxy? This talk explains how ghost objects and fake interface scan actually help you improve performance, memory impact and even simplify your applications!

I will show some practical examples of usage of proxies, their advantages and dis advantages, and even suggest you how to make PHP more awesome with bleeding-edge technologies such as react-php or Zend\ServiceManager.

Pairprogramming is one of the oldest practices known from XP and probably around way longer that any agile hype has been. Architectures and projects get more complex and large year by year and there is some evidence that problem solving is indeed easier and less error prone when executed as a group effort. This talk will outline the relationship of pairing to other agile practices such as Sprints, Daily Standups and Retrospectives. It is simply putting another, short cycled, loop in place to speed up problem solving and reducing bugs in produced code. However the narrative of software development tells us a great deal of (war)stories about solo coders saving the world in a lone effort. This is very misleading and might create a number of wrong assumptions about the craft in software development in general and could scare of interested young gun developers.

Pairing and in general working as a team can puts a highly effective and fun perspective on development projects in order  to solve problems quick, refactor code with more courage and experience flow state continously.

DataMappers like Doctrine2 help us a lot to persist data. Yet many projects are still struggling with tough questions:
- Where to put business logic?
- How to prevent our code from abuse?
- Where to put queries, and how test them?

It’s time to look beyond the old Gang of Four design patterns. There are Value Objects, Entities and Aggregates at the core; Repositories for persistence; Specifications to accurately describe object selections; Encapsulated Operations to protect invariants; and Domain Services and Double Dispatch when we need to group behavior safely. These patterns help us evolve from structural data models, to rich behavioral models. They capture not just state and relationships, but true meaning. These patterns protect our models from being used incorrectly, and allow us to test the essence of our applications.

The presentation is a fast paced introduction to the patterns that will make your Domain Model expressive, unbreakable, and beautiful.

Over two decades ago, Richard P Gabriel proposed the idea of "Worse Is Better" to explain why some things that are designed to be pure and perfect are eclipsed by solutions that are seemingly compromised and imperfect. This is not simply the observation that things should be better but are not, or that flawed and ill-considered solutions are superior to those created with intention, but that many solutions that are narrow and incomplete work out better than the solutions conceived of as being comprehensive and complete.

Whether it is programming languages, operating systems or development practices, we find many examples of this in software development, some more provocative and surprising than others. In this talk we revisit the original premise and question, and look at examples that can still teach us something surprising and new.

Software development is getting more and more complex. Does Joe Developer really need to care about how to configure routes and modules in his favorite framework or how to manage dependencies? Shouldn't he just focus on the business domain to get things done?

Learn about different techniques from code generation and scaffolding up to developing a domain specific language to make writing and maintaining applications more fun again.