eCommerce, July 2015
eCommerce, July 2015
Coding practices, June 2015
Coding practices, June 2015
It's easier in the world of today, especially as developers, to push ourselves too hard. Our community, like many, has seen an increasing number of stories about burnout and illnesses such as anxiety and depression. During this talk, Tom is going to share a little of his own story and the methods of managing it that he has found useful.
Immutability, unit testability, even the humble array_map - it's clear to see that functional programming has put down roots in PHP. So, what comes next? Tom introduces the idea of monoid folds, explains how it can help us to produce more readable and extensible business logic, and probably ends up defending Haskell in a room full of hecklers.
Building a Drupal application? You no longer need to download archives to add new modules or update core, or deal with Drupal specific tools to manage your codebase.With Drupal "getting off the island" there has been an increase in the adoption of common PHP tools within the Drupal ecosystem.In this lightning talk, I’ll show how to build a Drupal application using Composer for dependency management.
Dan is going to attempt to explain how to build modern testable application using a DIC container.
He’ll also talk about the limits of what can be written as clean code that makes you happy and you should handle having horrible untestable code.
Managing the security of your own project is one thing - but what happens when your software is installed on tens of thousands of hosting accounts that you don’t control? Find out how those challenges are faced with Perch CMS, and what happened last year when an exploitable security bug with found within a default plugin.
We all eventually gave up discussing that famous article describing PHP's bad design, bought our t-shirts and got on with our lives. Some of us decided to give Ruby a go. Or Go. We all know PHP is far from perfect but it's still one of the most popular languages on the web (thanks Wordpress!) so... just get on with it. Right?
There's a new kid in town. And it deserves your attention. Shame no more. Because PHP is not done yet!
Over 10 years since its last major release, PHP 7 is now out and available. Heck, we're at 7.0.5 already! All this hard work, sweat, tears and swearing in the community brought us significant performance improvements, drastically reduced memory consumption, a brand spanking new Zend Engine and a host of new language features to make PHP shine again.
Let's take a look at what's new. If you didn't get a chance to play around with PHP 7 yet I'll (hopefully) do the homework for you. If you're an expert already, looking forward to hearing what you think!
When people give talks on the "S.O.L.I.D." design principles one ofthe letters that doesn't get enough attention is the "i" - the"interface segregation principle". This talk seeks to redress thatimbalance by going into a bit more in-depth into:
• An introduction to interface segregation and an explanation of howit make your code easier to test.
• Why in PHP we need to apply the principle more broadly, to maketypes be more specific, so that code is more reasonable.
• Me babbling on about emotions, and how good code is boring. Which is good!
We're all excited about Drupal 8 coming up soon and we want to be ready for it! How can we make sure our code is ready for it? How can we build modules that are backwards compatible with D7 and future proofed for D8?
Learn how to build code decoupled from your platform and use it with Drupal or any other framework.
Do you work at a company where there are not enough unit tests in place and things are constantly breaking? Or maybe you have a client that always wants new features to be delivered as soon as possible, without enough thought about maintaining code.
How do you persuade people that Unit Tests should be written? And that by writing them you will improve your code quality and make development be easier? And how many unit tests should you be writing anyway?
Unit testing is an essential part of any successful software project, but it's only half the testing story. This talk will examine the other half of the testing story. We'll see why we need more than just unit tests and how to write these extra tests.
So, you've been through and changed all your double quotes to single quotes but your application still isn't running at the speed of light. What's going on?
Making an application scale is generally seen as something that only the most magical of developers can do, but it's easy once you have the correct tools. Fortunately for us, these tools are freely available online!
In this talk, we'll take a look at a few options that we have available to work out what our application is actually doing, help identify bottlenecks and fix them so that we can move on to the more important part of the project: delivering features.
Sculpin is a static site generator written in PHP. It converts Markdown files, Twig templates and standard HTML into a static HTML site that can be easily deployed.
This talk will cover a little of the background to Sculpin and what it is, and then will move into some demonstrations of how to build a Sculpin site and what it can do!
Nervous of version control? Don’t panic! you’re not on your own. I've put together a run down of some of my tricks and ‘good citizen’ techniques to avoid the worst kinds of conflicts and deal with the remaining ones as efficiently as possible. Branching policies, basic conflict resolution, proactive diffs can all ease the pain of a tricky integration.
This session will cover Regular Expressions from the basics to the darkest corners of this arcane art.
Regular Expressions at the core come in handy to achieve validation and text manipulation tasks. In the day to day life of a developer, becoming comfortable with them opens up many more use cases.
As one of the tortured souls that actually enjoys writing - and reading - regexes, Jordi will share his passion so that you too can see there is no reason to worry.
One of the new features that was introduced in PHP 5.5: Generators provide an iterable alternative to arrays, or to classes that implement the Iterator interface. At the simplest level, they don't add anything new to PHP that you couldn't already do before, simply returning values or key/value pairs to a loop; though they do give you options to perform certain iterative functions without the memory overheads of an array, or without the complexities of lots of boilerplate code that an Iterator class requires.
But look more closely at Generators, and they can be used for much more complex purposes: from simulating arrays with duplicate keys, or keys that aren't simple integer or string values, to accepting new data each iteration rather than simply returning it, so that you can actually modify their behaviour dynamically, or build Cooperative subroutines, even to simulate parallel processing.
Generators add real power to PHP.
Paul and Vítor will be showing off the newly released PPI 2.1, explaining what we’ve been working on and what extra value using an interop framework brings on top of just using a single standalone framework.
The PHP-FIG has recently put PSR-7 into vote (and by the time this talk is given it should be easily voted in). PSR-7 relates HTTP Messages; HTTP request and response objects that describe the interaction between a client and server in any HTTP exchange. While this doesn’t sound that interesting, PSR-7 threatens to open the door to truly interoperable libraries and frameworks, and heralds a new golden age for the next generation of PHP packages.
Join us in this brief introduction to PSR-7 and the core concepts around phly/http, a concrete implementation of the standard.
OrientDB is a graphing database like Neo4j, a document store like Mongo, and you can query it with SQL. This is a brief introduction to getting a server set up, loading it with data and getting that data back out in interesting and fun ways.
React is an extension that brings event-driven, non-blocking IO to PHP. With this new paradigm comes the 'Promise'; a fascinating and powerful pattern for handling asynchronous behaviour. I'll be using React to demonstrate how Promises rock, and why you should consider them for your own applications.
Code coverage analysis can be an incredibly useful metric for determining the overall quality of your test suite. However, as your codebase grows larger and more complex, so does the time taken to perform coverage analysis. I'll be sharing the tools and techniques we use at Radify to reduce our code coverage time by a factor of ten.
The deadline is looming: one week until we release the new version. Some features aren’t going to make the cut, but the boss really wants to make sure these critical bugs are fixed. You can’t wait for the release cycle to be over so you can relax.
But what if I told you it didn’t have to be that way? What if I could show you how to create a world where there is no release cycle? A world where weekend deployments are a rarity, not the norm?! In this talk we will cover the steps we took to achieve the coding utopia of releasing a feature as soon as it’s ready - many times per day. You’ll find out that by implementing a continuous deployment flow, you can empower your developers to take ownership and become more productive.
This talk will take you through the Event Sourcing design pattern, then go through how you'd implement it. From there we'll move on to CQRS, starting with what it is, then moving onto why it works well with event sourcing and how you'd implement it. Finally we'll wrap up with why it's probably not appropriate for most projects, and give some examples where it is appropriate.
How are you supposed to organise your models in an MVC application? What goes where? What is a service class, a mapper or an entity? This talk will look at the components of the model layer and the options you have when creating your models. We’ll look at the different schools of thought in this area and compare and contrast their strengths and weaknesses with an eye to flexibility and testability. We'll discuss the terminology and also take a look at what a service layer is and see how you use service classes to provide the business logic for your application and hide your persistence code from your controllers. By the end of this session you will be equipped to create excellent, maintainable models in your projects.
On one hand you're just grabbing stuff from a data source and shoving it out as JSON, but creating useful conventions from the start, surviving changes in business logic, handling database schema updates, and managing the shifting landscape of features creation and deprecated can be insanely tough.
This talk will outline some good the common pitfalls developers get trapped in when building APIs and give you some tools to make decisions about what you will do yourselves.
Interested in speaking?
We're always looking for speakers, so do drop us a line, regardless of your experience, we're all about first time speakers.
If you're looking for ideas, a few of the topics we're keen to hear about are:
- Debugging & profiling
- Lightning talks
- PHP7, PHPNG
- Support tools (e.g. phplint, boris, phpsh)