(Re)discovering the SPL

Session type: Talk
Level: Intermediate
Scheduled: January 25 09:00
Room: Permeke
Speaker: Joshua Thijssen

The Standard PHP Library (SPL) might be one of the most powerful, yet the most unused part of PHP, but you are one of those lucky developers who have discovered it! But now what? The lack of documentation about SPL makes it that a lot users don’t really harvest the power that SPL brings. During this presentation I will dive into the numerous iterators, data-structures and interfaces that SPL defines and when & how to implement them in your own projects, but we will talk about the edge-cases as well, as in SPL land things don’t always are what they seem..


Ansible: Orchestrate your Infrastructure

Session type: Talk
Level: Intermediate
Scheduled: January 25 11:40
Room: Beethoven
Speaker: Jeremy Coates

Software configuration management tools are gaining ground everywhere. We’ve all probably at least heard of puppet, chef or salt by now, however there’s a new rising star: Ansible. In this talk we’ll learn about the way ansible approaches configuration management, software deployment, remote execution and other general IT tasks. We’ll examine how to get up and running in a moment and how easy it is to manage multiple concurrent servers in parallel without needing additional daemons or bootstrapping! The talk will cover differences to puppet, chef etc and examine how to customise and extend Ansible with our favourite language. Join us for this talk and you’ll see why this award winning Python project has relevance for PHP and your work life through getting your servers under control.


Apigility: Agile APIs

Session type: Talk
Level: Intermediate
Scheduled: January 25 09:00
Room: Rubens
Speaker: Matthew Weier O'Phinney

PHP has a long history of intermingling HTML and code, but those practices are quickly changing. Today’s companies want to expose their content in a multitude of ways — either between organizations, to grow developer ecosystems, or to create mobile interfaces — and APIs are becoming the most important strategy for doing so. APIs pose a new set of problems for PHP developers: HTTP and content negotiation have increased importance; authentication and authorization must be handled quite differently; error handling must be done in a way that allows developers to understand how they can correct their requests; versioning takes a front seat, as clients may be pinned to older versions for longer periods of time. In this session, we’ll explore those issues, and how Apigility, a new project sponsored by Zend Framework, can help you accomplish these tasks via a new API dashboard, allowing you to write APIs that use brand new code or code you’ve already developed. Get agile in your API development!


Application monitoring with Heka and statsd

Session type: Talk
Level: Advanced
Scheduled: January 25 11:40
Room: Rubens
Speaker: Jordi Boggiano

Web applications are getting more and more complex and it is hard to keep an overview of your entire system. With the right tools we can get the relevant information out. This helps spot new problems when they occur, review application performance over time, visualize user behavior, and more. In this session we will look at packagist.org as a case study for monitoring, and see how we can improve reporting in various places to achieve better reliability of the service.


Clean Code ————- Apigility DEMO

Session type: Talk
Level:
Scheduled: January 25 13:40
Room: Van Gogh (Uncon)
Speakers: Carl Vuorinen , Matthew Weier O'Phinney

1st talk (30 min): Clean Code by Carl Vuorinen

2nd talk (30 min): Apigility DEMO by @MWOP


Code Obfuscation, PHP Shells & More: What hackers do once they get passed your code

Session type: Talk
Level: Beginner
Scheduled: January 24 14:40
Room: Rubens
Speaker: Mattias Geniar

What happens when protecting applications fail? What do hackers do once they’ve gained access to your source code, database and server? This talk will highlight some of the code obfuscation techniques used by hackers, as well as PHP shells and other backdoors used to keep access to a system. This talk will also include several methods of scanning and fixing both applications and servers from a breach, finding malicious code and removing it.


Code Review For Security

Session type: Tutorial
Level: Beginner
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: Anthony Ferrara

Imagine the day where you get an email from your CEO: “Our site has been hacked! Millions of user records have been leaked! And we’re being sued!”… Unfortunately, that situation appears to be quite common place in the modern world. In the past year alone LinkedIn, Sony, Zappos, Twitter, Apple, Yahoo and LastFM (and a lot more) have compromised, leaking over 100 million user records. How has this become common place? Developers traditionally haven’t focused on security (that’s someone else’s problem, right?)… Wrong! Security is everyone’s job!

Come and learn more about how to identify and fix security issues! In this workshop, we’ll cover the most dangerous and prevalent security vulnerabilities in PHP applications today. We’ll look at how those vulnerabilities work under the hood, and how to prevent them. Then, we’ll spend time reviewing actual code with actual vulnerabilities. Once we’ve identified a potential vulnerability, you will actually execute an attack against it! By the end of the workshop, you should be able to identify insecure code and fix it!

Who is the target audience of this workshop?
– Any developer who has preformed code-review before
– Any developer who wants to understand security better

How experienced do I need to be?
If you understand how to read code, you have enough experience to attend this workshop!

Tutorial requirements:
A laptop

A cursory understanding of the OWASP Top 10 will be very helpful


Continuous Delivery

Session type: Talk
Level: Intermediate
Scheduled: January 24 16:00
Room: Van Gogh (Uncon)
Speakers: Sophie Beaupuis , Jan Burkl , Frederic Dewinne , Pascal Paulis , Oswald Deriemaecker

Uncon talk


Continuous Integration in PHP

Session type: Tutorial
Level: Beginner
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: Keith Casey

As we move to the cloud, scaling, deployment, and operations in general become a fundamentally different kind of problem. Deploying an update via ftp or even resync simply doesn’t work anymore. Continuous Integration and eventually Continuous Deployment are the only approaches that keeps the code and our projects moving in one direction. This presentation will cover the major considerations in putting together your own PHP-based Continuous Integration environment and porting your first application.


Contributing without Coding —————- Community Works!

Session type: Talk
Level: Intermediate
Scheduled: January 24 17:10
Room: Van Gogh (Uncon)
Speakers: Jenny Wong (@miss-jwo) , Michelangelo van Dam


CQRS? Or did you mean CARS? ——————————— Build that PHING

Session type: Talk
Level: Intermediate
Scheduled: January 24 14:40
Room: Van Gogh (Uncon)
Speakers: Stijn Vannieuwenhuyse , Rick Kuipers

1. 30 minute talk CQRS? Or did you mean CARS? By Stijn Vannieuwenhuyse

2. 30 minute talk: Build that PHING. By Rick Kuipers


Creating PHP extensions

Session type: Tutorial
Level: Advanced
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: Julien Pauli

This tutorial will drive you inside PHP’s extension system. Under Linux, we’ll present PHP and its ecosystem, try to understand how it works then move to extensions. After foreseeing existing extensions, and theoretical concepts, we’ll start by making our own. We’ll learn how to enhance the language by adding functions, constants, INI options, classes, play with streams or change the engine behavior. There will be a main exercise, but feel free to bring your own business and get helped by your trainer or other attendees.

The final goal is that you have an accurate idea on how extensions work, and you can create at least a full skeleton of a PHP extension.


Design Patterns Workshop

Session type: Tutorial
Level: Intermediate
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: Brandon Savage

In 1994, the Gang of Four changed the world with their book, Design Patterns. Yet nearly 20 years later, we’re still struggling with design patterns. How can this be?

The answer is that design patterns are hard. Designing reusable applications is the most challenging thing a developer can do. But there’s good news: you CAN master design patterns and use them to your advantage! This workshop will show you how.

Learn how you’re already using design patterns in your own code, how to identify design patterns in the code of others, how to use eight of the most common design patterns (with live coding demonstrations!) and the ways in which design patterns can change your applications!


Development, By The Numbers

Session type: Talk
Level: Intermediate
Scheduled: January 25 10:10
Room: Beethoven
Speaker: Anthony Ferrara

Quite often we hear people talking about how to write better code, how to build systems better or how to leverage new technologies to produce better software. But how can we objectively quantify whether code is good or if it needs improving? How can we analyze an existing codebase to see what parts need improvement without spending weeks reading through the source code? The answer is provided by static analysis tools like pDepend and PHPLOC. But the results that they produce can be extremely cryptic and hard to understand. From acronyms like NPATH and CRAP to metrics like Cyclomatic Complexity and Fanout, there’s a whole treasure trove of information just waiting to be descifered. In this talk, we’ll explore some of the tools available for measuring software quality. We’ll dive into some of the theory behind the metrics that they analyze while looking at some real world applications of those metrics. We’ll also explore how to use these tools to gain valuable insight into legacy codebases. Finally, we’ll look into methods to integrate those metrics into your development workflow to help improve the quality of the applications that you build.


Docker, contain him, he is fast !

Session type: Talk
Level: Intermediate
Scheduled: January 25 11:40
Room: Permeke
Speaker: Joel Wurtz

It’s been four years since the philosophy of DevOps spread all around the world. This talk will begin with a short introduction of the current state of art of DevOps and all tools embracing its philosophy. Next, we will jump on Docker, the futur of automated system. How as PHP developer this tool can help us to be faster in our daily task and concentrate our work on our client not our technology ? By using him in our continuous integration system you will see that docker is just small part of an infrastructure and I will present you a complete stack around it which will make your PHP projects ship in the right channel.


Extract Till You Drop

Session type: Talk
Level: Advanced
Scheduled: January 25 16:10
Room: Rubens
Speaker: Mathias Verraes

We’ve all seen them: applications out of control. Under the pressure of deadlines and endless change requests, with the weight of years of legacy, the code has become unmaintainable. Adding features is a slow hit and miss process. You know something needs to be done, but nobody knows how. To change the code safely, you need tests, but to make it testable, you need to change it. Rebuilding the system from scratch is not an option. With the right tools, techniques, and mindset, any codebase can be brought under test, and be refactored towards a better architecture. All without affecting the behavior of the system, and allowing the business to continue. This presentation is not for the weak of heart. We’ll skip the theory and dive straight into the spaghetti code. We’ll wrestle in the mud, and we’ll tame the beast, whether it wants to or not. It’s live coding, and it may fail. But it will change how you approach legacy code forever.


Feature branches & PR’s – – Queue your work; about job queues and abstraction layers

Session type: Talk
Level: Intermediate
Scheduled: January 25 14:50
Room: Van Gogh (Uncon)
Speakers: Pascal de Vink , Jurian Sluiman

1st talk (15 min): Feature branches & PR’s by Pascal de Vink

2nd talk (30 min): Queue your work; about job queues and abstraction layers by Jurian Sluiman


Functional Application Design in PHP

Session type: Talk
Level: Intermediate
Scheduled: January 24 16:00
Room: Permeke
Speaker: Michael John Burgess

A review of contemporary application design in PHP, and the over-reliance on object-orientation to solve all problems. A major alternative to this paradigm, functional programming, is poorly supported in PHP, however there is still a lot of architectural inspiration we can derive from functional languages.


Getting started with content management in Symfony2

Session type: Tutorial
Level: Intermediate
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: David Buchmann

The Content Management Framework (CMF) is a set of building blocks for content management in Symfony2. You can use just parts of it to add some content management to your Symfony2 project, or use the whole stack to build customized CMS applications for specific needs.

In this workshop, we do a tour through the CMF. We will look at the existing functionality and I will do live-coding to implement additional features. This will get you a feel for how things work.

I will cover at least the following subjects:
– editing with create.js and sonata
– user editable routing with a database
– menu system
– block system
– media handling
– PHPCR-ODM Content repository with translation and versioning

You should have a basic understanding of Symfony2 or things might be a bit fast for you in this session. If you want to try out the CMF before the session, you best install the CMF Sandbox (https://github.com/symfony-cmf/cmf-sandbox) and play with it a bit.


Hacking with HHVM

Session type: Talk
Level: Intermediate
Scheduled: January 25 16:10
Room: Beethoven
Speaker: Sara Golemon

Did you know that one of the biggest PHP sites on the internet isn’t running PHP? Did you know that HHVM clocks in at anywhere between 2x and 10x faster than standard PHP with an Opcode Cache? Come take a look at “The other PHP engine”, how to get a server up and running, what pitfalls to watch out for in migrating over, and what exciting extras are waiting.


JavaScript/HTML5 Communication APIs

Session type: Talk
Level: Intermediate
Scheduled: January 24 16:00
Room: Beethoven
Speaker: Christian Wenz

HTML5 and related specifications come with a lot of new JavaScript APIs; communication is one of the most important aspects. It is now possible to send cross-frame, cross-browser tab, even cross-domain requests, receive push messages from the server, use bi-directional full-duplex communication, and more. This session will discuss these and other techniques, show code samples, and list helper libraries.


Keep an eye on your app with logging and graphs

Session type: Talk
Level: Intermediate
Scheduled: January 24 17:10
Room: Permeke
Speaker: Felix De Vliegher

Logging, metrics and graphs are often an afterthought. This usually becomes painfully clear when something goes wrong and you feel like you’re running in the dark with a blindfold on. You need to know what’s going on in your application! We’re going to have a deeper look at tools like logstash, statsd and friends to see how they can help developers and the business as a whole. You’ll fix problems quicker and will gain more insights in how your application is doing.


Keynote: Mentoring Developers

Session type: Talk
Level: Beginner
Scheduled: January 24 13:20
Room: Beethoven
Speaker: Elizabeth M Smith

How to train the next generation of Masters One of the best ways to move yourself forward as a developer is to have mentors who can help improve your skills, or to be a mentor for a newer developer. Mentoring isn’t limited to just ‘hard’ or technical skills, and a mentoring relationships can help in all aspects of any career – be it open source, a day job, or something else entirely. Learn some skills and tips from people who make mentoring an important aspect of their lives. From how to choose a mentor and what you should expect from a relationship as a padawan, to how to deal with the trials and successes of the person you are mentoring as they grow in their career. Also learn about setting up mentorship organizations, from the kind inside a company to one purely for the good of a community.


Let’s Learn Testing

Session type: Talk
Level: Intermediate
Scheduled: January 24 14:40
Room: Beethoven
Speaker: Tobias Schlitt

This session will get you started with automated testing using PHPUnit. Instead of throwing theoretical slides at you, I will do practical life hacking and show you in depth how to get started with unit testing and more.


Marrying front with back end

Session type: Talk
Level: Intermediate
Scheduled: January 25 14:50
Room: Permeke
Speaker: Bastian Hofmann

Most web frameworks are broken. They either just address the server side part of a web application (Rails, Symfony, Spring, Sinatra, …) or the client side (ext.js, YUI, Backbone.JS, amber.js,…) resulting in duplicated code, inefficient implementations and lots of boilerplate code. Recent node.js based solutions like Yahoo’s Mojito or Meteor are trying to change this, but what if you don’t start development from scratch because of a large legacy codebase or not wanting to use 0.x versions? This talk will feature and overview of an architecture that enables heavy reuse of even the smallest components by showing the details of the researchgate.net implementation. This approach enables developers to take page elements, like a single “follow” button, and place it everywhere on the site without having to duplicate any PHP, JS, HTML, CSS or AJAX endpoints in the process. Moreover it enables huge scalability, performance and UX improvements and should provide you with a couple of new ideas that are usually not explored in a classic (H)MVC approach.


Maximising Performance in ZF2

Session type: Talk
Level: Intermediate
Scheduled: January 25 13:40
Room: Permeke
Speaker: Gary Hockin

Zend Framework 2 is a complex beast, and has been wrongly criticised for it’s performance in a number of places. There are plenty of ways to eek out extra cycles from Zend Framework 2, some of them are known, some, not so much. Firstly you’ll be introduced to the ways to benchmark and profile your ZF2 app, then we’ll discuss the out-of-the-box improvements such as config caching and compiling, but also cover some bespoke modules designed to help your performance. Finally, we’ll cover some coding best practices that can really help to squeeze that little extra out of your entry level VM.


Model Storming Workshop

Session type: Tutorial
Level: Advanced
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: Mathias Verraes

Complexity in software hits us late in the game: long after contracts were signed, budgets were approved, and code was written. Big Design Upfront consistently misses the mark, but Agile methodologies don’t answer to the challenge either. Model Storming is an emergent practice in the Domain-Driven Design community, that brings modelling back to all stakeholders.

The workshop is similar to a hackathon, where developers tackle a problem as a team. But instead of writing code, you’ll be drawing models. We’ll start by explaining the domain, and then help you on your way to turn this into an expressive model. At regular intervals, we’ll break to discuss insights, and provide with you with new techniques and ideas to help you move forward.

No previous knowledge required; all you need to bring is your creativity and an open mind!


Models and Service Layers; Hemoglobin and Hobgoblins

Session type: Talk
Level: Advanced
Scheduled: January 25 09:00
Room: Beethoven
Speaker: Ross Tuck

Models, sure. That’s all part of MVC. Those are the objects that hold your business logic. Except…do they really? In PHP, the norm is to have an anemic domain model. Even if you want to move away from that (whatever it is), how do you do it? In this talk, we’ll look at different schools of thought for managing your code’s truly important parts and the impact on related areas like testing or form libraries. From plain models to service layers, DDD to CQRS, we’ll try to apply them to an average application using PHP libraries and see where they stand up or fall down. There’s no magic elixar for designing good models but sometimes all you need is a little iron in your diet.


Moving Away from Legacy code with BDD

Session type: Talk
Level: Intermediate
Scheduled: January 25 10:10
Room: Rubens
Speaker: Konstantin Kudryashov (aka everzet)

Greenfield projects are awesome – you can develop highest quality application using best practices on the market. But what if your bread actually is Legacy projects? Does it mean that you need to descend into darkness of QA absence? This talk will show you how to be successful even with the oldest legacy projects out there through the introduction of Agile processes and tools like Behat.


MySQL Server Performance Tuning 101

Session type: Talk
Level: Beginner
Scheduled: January 25 16:10
Room: Permeke
Speaker: Ligaya Turmelle

Optimizing the queries you send to the database can greatly increase the database’s performance, but what do you know about all those strange MySQL variables that can be played with to get even more power from the database? Join me as we go over some of the basics of the various MySQL settings you can twitch, tweak and massage to get the most out of your MySQL server.


O(ops), Authentication!

Session type: Talk
Level: Intermediate
Scheduled: January 25 14:50
Room: Rubens
Speaker: Andreas Hucks

When it comes to authentication for Restful Webservices, it seems every vendor is following another recipe. Some modes of authentication in use contradict the restful principle, some don’t. Some are secure, some are less so. We will take a tour of authentication schemes commonly found, discuss their pros and cons, and look at how to build secure, restful authentication mechanisms for your own API and various use cases.


Open-source maintainership: the Good, the Bad and the WTF

Session type: Talk
Level: Intermediate
Scheduled: January 25 16:10
Room: Van Gogh (Uncon)
Speaker: Jordi Boggiano


Philosophy of Programming // PHP Trivia Challenge

Session type: Talk
Level: Intermediate
Scheduled: January 25 11:40
Room: Van Gogh (Uncon)
Speakers: Michael John Burgess , Sara Golemon , Elizabeth M Smith

1st talk (30 min): Philosophy of Programming by Michael J. Burgess

2nd talk (30 min): PHP Trivia Challenge by Sara Goleman & Elizabeth M. Smith


PHP Performance: Under The Hood

Session type: Talk
Level: Advanced
Scheduled: January 24 18:20
Room: Permeke
Speaker: Davey Shafik

We’ve all experienced performance issues and we would typically turn to a profiler. Whether that’s something in userland, or a tool like xdebug or xhprof, the reason is the same: to figure out why our code is slow. This talk will take that inspection a step further and look under the hood of PHP, at the C internals, for common performance problems. If you’ve ever wanted to know exactly what your code is doing, and why ++$i is faster than $i++, this talk is for you.


PHP Under the Hood (Continued – Davey’s)

Session type: Talk
Level: Intermediate
Scheduled: January 25 09:00
Room: Van Gogh (Uncon)
Speaker: Julien Pauli

- PHP vars, ref, copies and memory consu.
– VM and other stuff
– OPcache …


Quality and Productivity; Best Friends Forever

Session type: Talk
Level: Intermediate
Scheduled: January 25 10:10
Room: Van Gogh (Uncon)
Speaker: Joeri Sebrechts


Refactoring to Design Patterns

Session type: Talk
Level: Intermediate
Scheduled: January 24 17:10
Room: Beethoven
Speaker: Benjamin Eberlei

Extensive use of Design Patterns is not something you should overengineer into your applications from the start. Practicing selective refactorings towards design patterns is a much better approach instead. In this session we will take a piece of real-world code and refactor it using three of the most important design patterns. The speaker will discuss the steps and the implications with the audience along the road.


Roll your own – choosing a PHP framework

Session type: Talk
Level: Beginner
Scheduled: January 24 18:20
Room: Rubens
Speaker: Rowan Merewood

Every PHP developer has written a framework at some point in their lives. The good ones realise what a horrible mistake it was. Like most good programming debates, it’s rarely so black and white. There are a wealth of choices out there, so how do you pick the right one for your particular problem? Full-stack or micro? Framework with CMS components or extensible CMS? We’ll look at a selection of frameworks and evaluate strengths and weaknesses.


Social human architecture for beginners

Session type: Talk
Level: Advanced
Scheduled: January 25 14:50
Room: Beethoven
Speaker: Sebastian Schürmann

No matter if you just have colleagues or organize people as a team lead or senior developer: There are some mechanics that apply to any mentally healthy human being and that have to be taken into consideration when you want to achieve good results as a team. This talk tries to give you a easy but valid introduction to some scientific findings about the nuts and bolts of brains and souls of the biggest investment your company probably has made: your teams.


Testing with Codeception

Session type: Tutorial
Level: Beginner
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: Jeremy Coates

We’ve probably all heard by now about Unit Testing, we may even have integrated Test Driven Development into our working practice. Less commonly known though are Functional and Integration Testing practices. Until now, at least in the PHP world, these have been quite hard to achieve. In this tutorial Jeremy Coates (@phpcodemonkey) will introduce these concepts and a tool chain to enable easy adoption.


The Big “Why equal doesn’t equal” Quiz

Session type: Talk
Level: Beginner
Scheduled: January 24 18:20
Room: Beethoven
Speaker: Juliette Reinders Folmer

We all compare and test data on nearly every other line in our code, be it input validation, an if-statement, a switch or determining what to display and how. So of course we are all experts on how to do these tests and comparisons…. Or are we? Come and join in on the Big “Why equal doesn’t equal” Quiz and show us whether you are an expert or a n00b in disguise… !


The first few milliseconds of HTTPS

Session type: Talk
Level: Advanced
Scheduled: January 24 14:40
Room: Permeke
Speaker: Joshua Thijssen

What happens when your browser connects to a HTTPS secure site? We all know it has to do something with certificates, blue and green address bars and sometimes your browser will give warnings which we normally click away. But what actually happens under the hood? In this talk I will give a step-by-step explanation on the first few hundred milliseconds during a connection to HTTPS. We will talk about master secrets, shared secrets, cipher suites, x509 certificates and why secure does not (always) mean secure. After this talk you not only can use HTTPS correctly, but also understand their basic foundations as well.


The NoSQL Store everyone ignores: PostgreSQL

Session type: Talk
Level: Intermediate
Scheduled: January 24 16:00
Room: Rubens
Speaker: Stephan Hochdörfer

PostgreSQL is well known being an object-relational database management system. In it`s core PostgreSQL is schema-aware dealing with fixed database tables and column types. However, recent versions of PostgreSQL made it possible to deal with schema-free data. Learn which new features PostgreSQL supports and how to use those features in your PHP application.


The seven deadly sins of Dependency Injection

Session type: Talk
Level: Intermediate
Scheduled: January 25 10:10
Room: Permeke
Speaker: Stephan Hochdörfer

There exist quite a few misconceptions when it comes to the Dependency Injection (DI) pattern. While the principal pattern is easy to understand, it can be difficult to succeed with DI. In this session I will share some of my real world experience with DI. I will guide you to use DI in “the right way”(tm) to get the most out of it and to increase the maintainability of your application.


Using Unicode with PHP

Session type: Talk
Level: Beginner
Scheduled: January 25 13:40
Room: Rubens
Speaker: Elizabeth M Smith

Your application is great – and popular. You have translation efforts underway, everything is going well – and wait a minute, what’s the report of strange question mark characters all over the page? Unicode is pain. UTF-32, UTF-16, UTF-8 and then something else is thrown in the mix … Multibyte and codepoints, it all sounds like greek. But it doesn’t have to be so scary. PHP support for Unicode has been improving, even without native unicode string support. Learn the basics of unicode is and how it works, why you would add support for it in your application, how to deal with issues, and the pain points of implementation.


Vagrant for PHP Developers

Session type: Talk
Level: Beginner
Scheduled: January 24 17:10
Room: Rubens
Speaker: Erika Heidi

Vagrant is one of the most mainstream tools on the devops world nowadays, specially between Open Source developers – now we can finally forget about the environment and focus on the code, without worrying about the “works on my machine” problem. This talk will evolve as a beginner’s guide for creating Vagrant boxes for PHP environments. It will cover the basic Vagrant concepts and give an overview about its main provisioners – Puppet, Chef and Ansible, including a set of protips to create better and optimized vagrant development boxes for different kinds of projects.


What to do when client wants to serve 110 MILLION geotargeted banners of a VPS?

Session type: Talk
Level: Intermediate
Scheduled: January 24 18:20
Room: Van Gogh (Uncon)
Speaker: @lmuzinic

Find out how to combine soft skills and developer tricks to end up with a happy client and a solution that can handle tens of thousands of requests per minute. Audience would re-live the journey from one insane client request to finished product that doesn’t need much resources at all, but rather one cleverly configured server (ngnix + memcache). Also, we learned a lot about caching from our own mistakes and I would like to share those as well.


Working with PhpStorm

Session type: Tutorial
Level: Beginner
Scheduled: January 24 09:00
Room: Designated Tutorial room
Speaker: Maarten Balliauw

PhpStorm, JetBrains’ IDE for PHP has a lot of features and because of that can feel a bit overwhelming at first. In this workshop, we’ll get our hands dirty: how does the IDE work? What can we do with the editor? What about inspections, quick fixes and refactorings? We’ll also see how to work with version control, the debugger, Composer, Vagrant, PHPUnit and much more!


Your (coding) standards matter

Session type: Talk
Level: Beginner
Scheduled: January 25 13:40
Room: Beethoven
Speaker: Volker Dusch

Nowadays it is easy to dismiss a discussion about coding standards with “Everyone already has one!” and move along. But upon closer inspection that doesn’t really hold true. Just having a coding standard is meaningless if not everyone is following it and nobody bothers to check the code against it! Even if that happens people should also understand WHY those rules exist and how the help to speed up development! This talk is suggesting that just having a piece of paper that has all the rules written on it is just as pointless as not having a standard at all, maybe even more hurtful. PHP has grown up to be a very mature and reliable language with many great tools supporting our development. We as php developers have the ability to easily create, adapt and maintain a EXECUTABLE definition of our preferred coding practices! Showing how to use and configure the appropriate tools this talk goes on to explain why it REALLY is important to have a coding standard and how to create and maintain one. Should you choose an existing one and stick to it no matter what? Should you spend a week getting all your developers to agree on something or is there maybe an easier way to get a group of people to follow a common set of goals they agreed upon? And what to you do with a new coding standard when you already have a massive code base that doesn’t follow those rules. Having 10.000 violations can’t be the answer! Ending with a short description of how problems can be easily detected and visualized, to really HELP and not hinder developers, this talk hopes to show to you that it is possible to have a coding standard for big teams and even for the smallest projects!