Frameworks: The Good, The Bad and The Ugly
Richard Johnson, Michael Peacock, Enrico Zimuel, Bastian Hofmann
Start reducing complexity and start reusing sets of methods freely in several independent classes living in different class hierarchies with traits. Learn the semantics and start living in the future of PHP now!
Complex event processing is at the cutting edge of reactive systems in business and finance, where early detection of patterns is used to get just ahead of the curve. In this talk we will see how by using react PHP and a few simple functions we can build reactive systems that can give use much of the power of commercial CEP but at a fraction of the complexity.
You may see Nginx as the run of the mill web server, geared towards serving up static files and your language of choice but there is so much more to Nginx than that. Under the hood is a treasure trove of additional features and configurations that can help you take things to the next level. This includes having Nginx talk directly to Memcached / Redis (perfect for APIs, without hitting your application), proxy functionality, GeoIP, Lua in the config, MogileFS file serving, improved headers manipulation, and the less useful yet cool ability to query Drizzle / Postgres directly. This is only the tip of the iceberg. I will take you one a journey to explore the hidden corners of Nginx and show you how to crank it up to 11!
It's been a year since the release of PHP 5.4 and the next version is already in the making. The talk presents the features of the upcoming PHP 5.5 version that is close to be released in April/May 2013. We are looking in Generators, a new password API, check what was deprecated and show how to write idiomatic PHP 5.5 code.
Syntax is for machines, words are for humans, and code needs to satisfy both. It is easy to forget that once your carefully crafted code leaves your hands it isn't the problem you've been trying to solve any more, it has become a solution. The reason why you chose your solution over another is important and you have to make it clear to the next programmer who reads your code. This is when you have to unleash your inner author, and start communicating with your reader. That reader is the next person who needs to add to or fix your code, and more times that you'd like to admit - that reader is yourself. Think about that person when you code, and future you will thank you. This talk will cover why reading code is a dreaded task, we'll have a look at what "the trigger-trap" is and how you can avoid it, and we'll finish off with some writing tips to the programmer.
PHP extensions provide the "glue" between the PHP language and C/C++ libraries. This session will provide an intense, and fast paced introduction to writing custom extensions. Attendees should ideally know C/C++ already. Time permitting, HipHop extensions may be covered as well.
Ten years ago the Amazon Web Services platform was launched and in that time it has dominated and shaped the way cloud computing is viewed. Even after a decade there are still a lot of buzzwords flying around and putting your app in the cloud is often sold as a simple, cure-all solution. So what's really involved? This talk will give you a hands-on walkthrough of building a PHP application stack in AWS. We'll start by deploying a simple Silex application to the Elastic Beanstalk and then add in a selection of other AWS services. This is not a theoretical, text-book session - this is real-life configuration with the cool concepts and tricky hacks that involves.
Many talks discuss REST as if that is all you need to know when building an API. It's a good start, but once you try to build something that works, you will soon discover that it takes a lot more than good resource-centric URL design and HTTP verb use. In this talk, I will discuss what is involved in building an API so you don't need to discover it by yourself. The spectrum ranges from a brief recap of RESTful principles through to handling metadata and even (horror of horrors) documentation. Learning about these fundamentals will allow you to prepare your design before writing a single line of code. You can plan development with this in mind, allowing you to deliver a more capable and flexible API to your customers from day one. It can also make it easier and more enjoyable for people to build against your API, encouraging the growth of applications and an ecosystem around it. This talk has evolved from my own experience as both an API consumer and creator.
Every programmers have already experienced a "Fatal error: Allowed memory size of xxx bytes exhausted" error message. This talk is highly technical and will explain the attendees how memory works inside PHP with understandable words and schemas. We'll start by refreshing minds about what memory is, and how it works on the system and then focus on PHP case by introducing its main memory component known as "Zend Memory Manager". You'll discover how PHP uses memory and above all : how you can figure it out into your everydays scripts and how you can be more efficient about it.
What do you do if you have a single letter Twitter handle and your reply stream is useless due to people misusing and abusing the @ sign, like "I'm @a bar"? Machine learning to the rescue! I will explain how I used ML and a couple of other tricks to build a program that sanitizes my Twitter mentions and will hopefully inspire you to use ML in your own projects.
"Why should we write our tests first? Isn't that going to slow my development?" "What? Assigning a single task to 2 developers? How is that efficient? What a waste of resources!" "Look, in the perfect world your advises are great, but I have a project to finish here." In this talk Marcello explores efficiency in contrast to effectiveness. He looks into how practices, traditionally accepted as efficient, sometimes turn out to be less effective than a few "impractical" things he has come across.
Refactoring code is an important aspect of maintenance and development, but when a large application needs to be extensively refactored, often a developers goto suggestion is to rewrite it. An alternative: The symfony2 components, and their friends; standalone implementations of a range of common website features, separated from the symfony2 framework. These components provide an excellent base for any framework or application. This talk will look at how these components can be used to refactor applications of any size, through real world examples picked up from refactoring a large high-content, high-traffic news website.
A how-to guide on identifying bottlenecks and scalability challenges within web based applications. The session will do an in-depth coverage of the tools involved and how they can be used in real-life situations as well how to go about correctly interpreting the results and correlating them to flaws in the code and/or infrastructure.
PHP is a great little language, but it’s had a troubled upbringing. While many languages have been conceptually thought through, designed with a consistent API and the benefit of large amounts of corporate backing; PHP was instead born from one geek's desire to quickly make dynamic web pages, tapping into underlying C libraries where needed and being grafted awkwardly into web servers. This makes the language incredibly accessible, fast to learn and work with, however there are huge skeletons in the closet. Without proper care and attention, these skeletons can suddenly spring to live and devour everyone you love. This talk will attempt to cover a wide range of web system security considerations including: - Evolution of PHP's security features; - General PHP development best practices; - Considerations when using underlying C libraries; - Fun PHP functions and unexpected results; - Cool “features” in browsers; - LAMP stack design and configuration for security; - Common mistakes and gotcha’s; - Security antipatterns and fallacies; - How to review code and think securely. Won't somebody please think of the children...
Open Source in Action
Sara Golemon, Martijn Verburg, Ian Barber, Beth Tucker Long
In this talk we are going to see a short theoretical introduction to RabbitMQ and messaging in general to later dive into a live coding session to see how implement messaging into our applications. The live demo will go from starting the server and issuing basic administration commands up to creating several consumers and publishers. We will implement use cases ranging from a basic queue server to a publish subscribe system. The goal of the talk is two fold: to see how easy is to implement a solution around messaging and to understand that we don't need to be a "big player" in order to take advantage of RabbitMQ.
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.
Vagrant combined with Virtual box and a provisioning tool like chef or puppet fundamentally changes the way developers setup their development environments and develop their web applications. Once configured, vagrant allows developers to spin up a new environment in a couple of commands and allows each developer to have the exact same development environment. As PHP developers, our development environments differ significantly. Vagrant solves this by allowing developers to create reproducibly development environments on the fly when and where they are needed. Yes, it is true there are now at least half a dozen LAMP installers out there, each one has slight variations on what and how it installs and how it works on different operating systems. Some developers don't use an installer they might decide to compile from source, use what comes with the latest mac osx or develop directly on a server in the cloud. However, the eco-system around PHP is forever changing and setting up reproducible complex development environments in an automated way is extremely useful. My talk will cover vagrant in detail and enough around virtual box and chef to get developers going so that they can use these tools in their everyday development environments. These tools and skills are a great asset for all PHP developers.
Software engineering is not an easy profession. You have to constantly learn new things to improve your coding skills and make sure you produce better and cleaner code over time. It’s not difficult, but you have to be aware of a few basic principles. With them in mind you will feel a better engineer and will gain respect from your fellow engineers. And the Lord said: “Thou shall always remember to write unit tests - no matter the deadline. Remember to keep the build green. Thou shall commit often and with meaningful messages (...)”
The new architecture of Zend Framework 2 is based on a new MVC design that uses events and modules. In this talk we will show how to build web applications in ZF2 using the SOLID principle (Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion). We will show how to use Events to manage the application flow, how to organize and reuse the code using Modules and how to separate the responsibility using the new MVC design of ZF2.
HipHop is the Open Source PHP language compiler and runtime designed and used by Facebook. HipHop offers a significant speed improvement over the official PHP runtime and supports most of its core features. This session will provide an introduction to how and why to use HipHop over PHP, and the benefits it offers.
This presentation introduces OpenStreetMap and explains to the audience what sort of rich data set it has. I will also cover different APIs for using the map tiles as well as other APIs that form sister-projects to OSM, such as Nominatim (search), routing, and obtaining current-location information. Some hints on storage and searching will also be given. During the course of the presentation I will also have to dip into some of the theoretical issues surrounding map making in general.
Troubleshooting MySQL doesn't need to involve trial-and-error, and it doesn't need to take a long time. You need only two things: a good process and good tools. This session will show you an approach that the speaker has used to solve many frustrating problems quickly, and open source tools that assist this process. The tools especially include key tools from Percona Toolkit.
Looking at how to build highly available systems in PHP by planning to fail. This talk will offer a number of heuristics that will help you build highly available systems including choosing technologies, software design patterns and failure simulations.
Applications are complicated structures, usually consisting of a lot of moving parts and thus it's not so easy to tell if an app is not functioning properly. Luckily nowadays there are tools to monitor applications in production to both detect code level problems and most importantly also business-logic level problems. Let's look at various different tools to record and analyze metrics and how this could be useful to make sure an application is running correctly and a recent commit hasn't decreased it's performance.
A lot of people will tell you that unittesting is easy, but in practice it's one of the hardest disciplines to get right. When you've never written unittests before you'll probably have a million questions really fast; your code has got a lot of dependencies, runs queries on your database and sends out e-mails, and there seems to be no way to write reliable tests for this code that you can actually use time after time. No worries! Harrie is here to help :-) This talk is a hands-on introduction to writing unittests using PHPUnit. We'll be writing some actual unittests for (sometimes problematic) pieces of code that you could come across while testing real-life applications. I'll explain how you could apply TDD and how to use it into your advantage, and I'll come with some suggestions on how you could convince your boss that unittesting is important and actually worth the effort on the long run.
This talk will demonstrate using the PHP extension for OpenCV to allow PHP to detect and track features in images and video. The basics of image processing will be covered, before extending these to the more advanced features of the OpenCV library including face detection and panorama stitching.
Not everyone has access to a user interface designer, but that doesn’t mean that usability is out of your reach. This talk will cover user experience basics along with simple, easy-to-implement tricks to improve usability. This talk will also cover ways to test if your site or application is making the grade.
At a certain scale, millions of events happen every second, and all of them are important to evaluate the health of the system. If not handled correctly, such a volume of information can overwhelm both the infrastructure that needs to support them, and people who have to make a sense out of thousands of signals and make decisions upon them, fast. By understanding how our rational mind works, how people process information, we can present data so it's more evident and intuitive. This talk will explain how to collect useful metrics, and to create the perfect monitoring dashboard to organise and display them, letting our intuition operate automatically and quickly, and saving attention and mental effort to activities that demand it.
It’s been possible to instantly push information from a web server to a web browser for at least 10 years, but this technology has finally gone mainstream thanks to technologies like WebSockets and solutions like SignalR, socket.io, Faye and Pusher. In this sessions I'll cover the past, present and future of client/server communication technology, the realtime web and provide a number of use cases and demonstrations of how the technology is actually used today (it's not just chat and spaceship games).
The Diabolical Developer has spent the last few years utilising best practices in various languages, following lean/agile techniques, practising software craftsmanship and listening to the likes of Martin Fowler, Derick Rethans and Rasmus Lerdorf.
He's discovered that it's all just one giant hoax and he wants to expose the lies that you've been told your entire careers! This talk is going to change your life - you'll learn practical steps on how to free yourself from the oppressive chains of the industry (and your so called betters) and actually get back to loving development again.