4 Design Patterns to Make Better Code

Design patterns is a idealistic word in the programming community. We all want to attain the nirvana of using design patterns, but we don't want to take the time to change our thinking on how we approach the problems we solve. This talk will give you 4 design patterns that are easily integrated into your workflow, but will give you systematic approach to solving problems. From factories to dependency injection and more, you will leave this session with a good understanding of these design patterns.

Adventures of a Contract Developer

Thinking about quitting that desk job and enjoying the freedom of contract development? Already have?

A contract developer for 10 years, I'll share my philosophy on contracting, some tips on how be successful, and a look at some of the clients you'll run into.

While my style of contracting may not work for you, this talk will at least challenge you to consider not just how you're marketing your product, but what your product really is, how you charge for it, and what that means long term.

Already a contract developer? I'll give some tips on avoiding the painful parts of the job, setting and negotiating your rate, and one simple way to get great clients and keep them happy.

Considering contracting? Meet some of the clients you'll certainly come across, a few warning signs and things to watch out for, and what needs to happen in each case before you can have a successful relationship.

Automation: Work smarter not harder

Do you ever feel like the small repeatable tasks get in the way of being able to write code? This talk is focused around the idea of automating those tasks and ensuring that the bulk of your time and energy can be dedicated to building software. The applications of this talk are further reaching than deployments, running tests; we'll get into workflow automation with Alfred in addition to covering tools like Phing, Ansible and how to use shell scripts to make sure that those pesky one off tasks can be completed consistently without disrupting your day.

Behat: Beyond the Basics

Join me for an in-depth look at intermediate to advanced level Behat topics. Thanks to Behat, my company was able to take an application that only functioned about 50% of the time and had almost no forward progress due to bugs and regressions, and make it stable, tested, and are now adding features and releasing at least weekly. Learn from my years of experience in my talk on Behat: Beyond the Basics.

In this session we will cover: - Guidelines to follow for writing accurate and easily understood tests - Going from having no automated testing to having a stable product - Testing legacy code vs new code - Technical specifics: - Capturing a screenshot on error - Dealing with AJAX in your application - Regular Expressions in Behat Contexts and more.

Bring your web application architecture to the next level with React.JS

React.JS is a very powerful library for building user interfaces and the new, cool kid in the JavaScript world. But it is also very interesting for creating a fast, maintainable and interactive web application. In this talk I'll show what React is all about and how you can combine and integrate it’s power with your web application, even if you have to render out HTML on the server side. Especially common pitfalls for getting data from your backend to React will be covered. The result will be a flexible, component based architecture that enables developers to take page elements, like a single "follow" button, and place it everywhere on the site without having to duplicate any backend code, JS, HTML, CSS or AJAX endpoints in the process.

Building A Developer Platform: From (o)Auth to Zen

You've built an API to support your company's internal technical needs, and now you're thinking about opening it up either to the public or to a set of approved third-party partner developers. What's next? At NPR, we've spent the last year building a developer platform for our cloud-based listening app, NPR One, and the six key technical components that we've focused on are: * authorization (using OAuth 2.0) * documentation * permissioning * rate limiting * self-service console * versioning strategy Come learn how we did it, including lessons learned, things that (often to our own amazement) worked out well, and a myriad of things that we wish we'd done differently, from an NPR developer. (And yes, we did it all in PHP!)

While not highly technical (there won't be much, if any, code on the screen), this is intended to be an intermediate-level talk; ideally, you'll have built an API, are totally comfortable talking about your tech stack, and have built or used an OAuth client in the past, so you're familiar with the general principles of the OAuth 2.0 protocol. Matt Frost's "Introduction to OAuth Clients" last year is an excellent prerequisite, though not a requirement.

Building PHP Daemons & Long Running Processes

There are things you don't want to, or can't do, inside a web request. It could be a task that needs to be retired if it fails, maybe one that takes a significantly long time to process, or multiple jobs that need to be processed over time. Whether you're sending an email, processing a video, or consuming Twitter's streaming API, you should be using a separate process, and probably a daemon. Learn how to stop abusing cron, and easily daemonize a PHP script that responds responsibly to process signals.

Building Simple Micro Services using Slim 3.0

Developing monolithic applications that run on giant servers with no horizontal scaling has been becoming less of the standard in PHP. Scaling out can be a huge issue that many companies face and don’t think about at the start. This course will teach the basics of Slim 3.0 and how to integrate a Database Abstraction Layer into Slim for creating a robust scalable API for all calls with OAuth v2 authentication. We will also help teach the fundamentals of what makes microservices so reusable and ways to help build and maintain a farm of microservice based APIs using Slim. Slim contains middleware which help make creating modularized services a snap.

Building Web Sites that Work Everywhere

How to build web sites that work well across various browsers versions and devices is always challenging for web developers. In the session, you’ll learn the best practices and strategy to develop cross-browser web sites that will work with the existing and future browsers. Tools for interoperability tests, cross-browser fundamentals, and tips and tricks on HTML5, CSS, JavaScript development will be illustrated. Feature detection, CSS prefix, and fallbacks will all be examined in the session. A real life example will be used to demonstrate step by step how to build cross-browser and plug-in-Free experiences. With a couple of simple changes to your sites, you can take advantage of web standards and HTML5 features today without breaking your sites in the future. Expect a lot of demos and code in the session.

Conscious Uncoupling - Building Software That Lasts

"By using a comprehensive feature-filled framework we can build software fast. On the other hand, by decoupling our applications we can build sofware that is independent of our framework and infrastructure choices, and therefore longer lasting.

We can't do both, is one approach always right?

In this talk we'll look at different decoupling techniques, what problems they solve, and when they make sense. We will learn some concrete techniques to discover where we should be investing in decoupling, and when we should let the framework maintainers do the work for us."

Containing Chaos with Kubernetes

Okay, you've made the move to containers and can now write Dockerfiles for everything. How do you manage all of those containers?. Have you found that you traded managing individual machines for managing individual containers?

Kubernetes, an Open Source container orchestration engine, can be your answer. We'll explore Kubernetes and see how you can use it to run massive collections of containers that fix their own problems and allow you to move your setup wherever you need to be.

Database Theory, Models and Abstractions

Proper database theory and design seems to be an increasingly lost art. As abstraction layers, migration tools and ORM become more prevalent, less focus is being spent on properly architecting the database, relationships, indexes and constraints. As a result, many projects suffer a crisis of data or scalability as data sets grow.

In this talk we'll cover: Table relationships and relationship tables Database Normalization with a focus on Third Normal Form (3NF) Database Indexes and Use Cases Database Keys and Composite Keys Database Optimization. The difference between schema and schema-less databases, and finding the proper database to suit your requirements.

Demystifying OAuth2: an understandable way to approach connecting to other systems

OAuth2 can be a dirty word. It can seem to be hard to understand. However, it is super easy to connect to 3rd-party applications and work with customer data in a secure means that does not involve the user giving you their password. In this session, we will cover what is OAuth, how to use OAuth with PHP, and ideas for what you can do with OAuth.

Demystifying Object-Oriented Programming

Abstraction, Encapsulation, Polymorphism, and Interfaces: whether you’ve been programming in PHP for years or are just starting your journey, these terms can be overwhelming even on a good day. Variables, conditionals, those all make sense. But this whole Object-Oriented thing is WAY more complicated. Not only that, people that already understand it act like it’s so easy and they talk right over the simple questions and never explain the basic concepts in a way that actually makes sense. In this session we’ll take you through real life examples of Object-Oriented terminology in a way that will make sense of all the mumbo jumbo and allow you to utilizing OOP immediately.

Docker for Developers

Thanks to tools like vagrant, puppet/chef, and Platform as a Service services like Heroku, developers are extremely used to being able to spin up a development environment that is the same every time. What if we could go a step further and make sure our development environment is not only using the same software, but 100% configured and set up like production. Docker will let us do that, and so much more. We'll look at what Docker is, why you should look into using it, and all of the features that developers can take advantage of.

Driving Technical Change

Ever been to a conference, get inspired, try to bring what you learned back to the office, only to be stymied by co-workers who aren't interested in rocking the status quo? It turns out that people tend to resist change in patterns, and like any pattern they can be overcome by using other people's experiences with those skeptics. This session will teach you how to identify the skeptics, how to counter them, and give you a strategic framework to convince your whole office.

Effective Redis for PHP Developers

Redis is a key-value store that has carved out a role for itself as a data structure server. If you're using it only for caching simple values, you're tapping a mere fraction of its power. This presentation provides an introduction to Redis and the Predis client library for it as well as related data structures that Redis supports and when it's best to use them. No computer science background is necessary; data structures are presented in understandable terms with practical examples.

Exploiting the Brain for Fun & Profit

Sure, you could improve yourself or promote your project the normal way, with hard work and years of slow, incremental progress. Or you could use some of the brain's built-in cheat codes and just hack your way to success.

Along with learning, our brains are plagued by a raft of bugs and unwanted features that we have been unable to remove. Use these "features" to your advantage to teach, learn and persuade. Join us in a tour of some of the most amusing bugs and exploits that allow you to play with the interface between our brains and the world.

Hacking your way to better security

The goal of this talk is to educate developers on common security vulnerabilities, how they are exploited, and how to protect against them. We'll explore several of the OWASP Top 10 attack vectors like SQL injection, XSS, CSRF, session hijacking, and insecure direct object references. Each topic will be approached from the perspective of an attacker to see how these vulnerabilities are detected and exploited using several realistic examples. Once we've established an understanding of how these attacks work, we'll look at concrete steps you can take to secure web applications against such vulnerabilities. The knowledge gained from this talk can also be used for participating in "Capture the Flag" security competitions.

How To Cope When It All Hits The Fan

"Hope for the best and plan for the worst." We spend a lot of time talking about best practices: the ways we should run our projects and write our software so that everything turns out as well as possible. But when you add human beings to the mix—whether they’re coworkers, clients, or, well, you and I—something will eventually go wrong.

Using case studies from the interactive agency world (where no two clients are ever the same), we'll talk about methods for triage, what to do when you sense a project is on shaky ground, and ways to ensure everyone gets to the other side in one piece.

HTTP is Dead, Long Live HTTP/2!

Request for Comments (RFC) 2616 reigned supreme as the specification for the hypertext transfer protocol (HTTP) for fifteen years. Now, it's been obsoleted by a handful of new RFCs, and HTTP/2 is a reality, having been published earlier this year. In this talk, we'll take a look at the new RFCs, discuss the differences and clarifications they make, and take a look at what's new in HTTP/2 and what it means for you.

Is your API Misbehaving?

Most API testing is a joke. We have things that resemble Unit Tests which are really integration tests which really just wrap our personal understanding in just a bit of code. And at the end of the day, we’re still not sure it works. Instead, let’s flip the entire experience around and look at it from the API consumer’s point of view and confirm that we’re solving real problems for real users. In this talk, we’ll dive into some of the benefits of Behavior Driven Development and build some examples.

Learn Unit Testing with Katas

In this talk we'll introduce the core concepts of unit testing and TDD — what it is, how it's done, why it matters — and then jump into doing it with one of the most time-tested techniques to comfortably start to get comfortable with the idea: code katas.

Code Katas are a systematic practice where you solve a specific code problem for about 25 minutes. After that, you throw the code away! This means they're the ideal safe places to learn new things and stretch our boundaries. We'll do one live front-to-back so you'll be comfortable taking the idea and doing it on your own.

Measuring and Logging Everything in Real Time

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, Elasticsearch and Logstash, without influencing your production environment.

Mentoring Developers

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.

PHP 7 Crash Course

PHP 7 was recently released, bringing some much-desired changes and improvements to the language. However, many developers haven't had the opportunity to use it for their projects and may not be familiar with the changes it brings. We'll remedy this by checking out the new "spaceship operator," demonstrating how static type hints produce clean code, and using anonymous classes to quickly implement interfaces on the fly. Attendees will also learn about breaking changes and "gotchas" to watch out for when making the upgrade and will receive pointers on getting started with PHP 7 today.

PHP Foundations

PHPEmbark is designed for people with no previous programming experience who have basic knowledge of html and css to get a quickstart into programming

Required: A computer running Windows 7 or 8, OS X 10.6 or newer, or a Linux variant (we will assume Ubuntu Desktop for the purposes of this course), The ability to navigate the filesystem, including creating and deleting files and folders, The ability to download and install software on your computer, Basic knowledge of writing html and css

The syllabus is divided into 4 sections

Part 1: Programming Logic - we'll cover the very basics of programming variables, logic, conditionals and looping, functions

we'll then move into data types and math and type juggling we'll end with more complex data structures common to php - objects and arrays

Part 2: The Internet - we'll cover what http is and some basic theory how requests and responses work an overview of html, css, and a very small section on javascript and the concepts behind server vs. client side programming

then we'll move into basic http verbs get and post and work with forms

Part 3: SQL and Crud using sqlite we'll go over teh basics of sql and how it works, and learn about insert, update, delete, and select

then we'll tie together our new internet forms knowledge with our new sql knowledge

Part 4: Code Design We'll learn the basics of setting up a simple project: - separation of concerns - php "templates" - best practices for simple projects - ways to find help and support as you continue learning

Each section will have a portion that is lecture, a small amount to read online, some practice examples and "quizz"/practice style questions and end with some practical example

By the end of the class we'll have put together our practical examples into a functioning application

PHP7 and Beyond: The Future of PHP

PHP is experiencing a renaissance; old methodologies are everywhere under assault from advances in tooling and design. From Composer to HackLang, "the PHP way" of solving problems is dramatically evolving. Walls between projects are falling; interoperability and collaboration are happening on levels never thought possible. What do these accelerating changes mean for the future of the language? What might PHP8 look like? How will our communities continue to collaborate and evolve? And most pressing: what steps can we take to ensure PHP's continuing vibrancy in the face of future technical challenges?

Rebuilding our Foundation: How We Used Symfony To Rewrite Our Application

This talk is about how my company took a broken e-commerce and LMS site written in an older style MVC framework and re-wrote a significant portion of it in Symfony and related tools (Doctrine, FOS Bundles, Sonata) over 6 months and created a stable, well-tested application. I’ll cover the approach we took to rewriting the admin panel in Symfony, writing an API, introducing Behat and PHPUnit tests for both new and legacy code (still in a separate framework) and setting up Continuous Integration. I’ll discuss how we optimized the site as we went, by identifying weak spots in the code and how we addressed them. I’ll also cover what we would do differently now that we’ve done it once.

Relational Theory for Budding Einsteins

Relational Databases have been around for decades but very few PHP developers have any formal training in SQL, set theory, or databases. This session is a crash course in efficiently using a relational database, thinking in sets (better know as avoiding the N+1 problem), how simple Venn Diagrams can help you understand JOINing tables, how to normalize your data, smart query design, and more. If you are a developer who wonders why your queries run poorly, want a better understanding of query optimization, or just learn some of those 'dark arts' this tutorial is for you.

Rethinking Loops

You likely learned about loop constructs very early in your programming career and use them every day--so often you don’t think twice! The problem is for() and foreach() are so fundamental developers use them for everything! Even worse almost every developer will use them differently to accomplish the same goal. So what would intention-revealing PHP code look like without using for() and foreach()? Let’s explore some functional programming concepts and find out!

Knowing basic functional programming concepts will improve your PHP code. Your new mindset will favor writing code with better separation of concerns and decreased complexity: clean code. We will explore some poor examples of using loops to process data, then ease into learning functional concepts like map, reduce, filter and collection pipelining. We'll then use our newfound knowledge to refactor a large foreach() loop to use the new techniques. Lastly we’ll explore some existing libraries and even experimental PHP RFC features to make our code even more concise. Beware: after this talk you'll never look at for() and foreach() loops the same again!

Shattering Secrets with Social Media

Wouldn’t you like to know about the things that aren’t being talked about? Professionally, how can you look at a “stealth startup” and figure out what they’re doing and how they’re doing it? How can you learn about their investors, products, and even potential customers? Who are the Connectors?

For years now, we’ve had sites like LinkedIn, Meetup, Facebook, and Twitter making a stunning amount of private information available for all to find, browse, explore, and combine. Previously getting at this data often required screenscraping, esoteric agreements, and sacrificing a goat. Thanks to the explosion of APIs and good API design, we can collect and analyze this information faster, easier, and better than ever before. This conversation will cover some tips in collecting the data along with some of the patterns discovered and suspected.

Step Into Debugging

<?php die(var_dump($synopsis));

string(406) "While var_dump driven development is great when your starting, at some point every developer wants more. Step debugging is the answer.

In this session we'll cover the fundamentals of installing and configuring Xdebug, configuring PhpStorm to listen to Xdebug, and then actually step debugging some scripts to find our problems. Step debugging PHP is an incredibly easy and powerful tool when you know how!"

Stop multiplying by 4: Practical software estimation

Many developers are often asked by project owners to give time estimates for features or bug fixes. But how many developers have the ability to provide project owners a reasonable estimate? Many developers will just follow irrational formulas or arbitrary methods to create a number that is not only wrong, but costly. "Stop Multiplying by 4" will teach developers of all skill levels easy techniques to provide accurate estimations. We will start with a small calibration exercise to find out how good you are. We will then go over procedures to improve accuracy . At the end of the talk, you will possess the skills to get you started on improving the certainty of your estimates.

TDD with PhpSpec

PhpSpec is a SpecBDD tool that enables you to use a TDD workflow that can transform the way you write PHP. In this session we will look at the TDD workflow and see how PhpSpec can be used to speed up your development; add regression safety, and improve your object-oriented design.

Terrible Ideas in Git

Adapted from his class "The Screaming Horrors of Git," Corey takes us on a magical tour through the (mis)use of Git to do things its creators never intended. In this humorously delivered exploration of one of the open source community's more ubiquitous tools, Corey demonstrates that a finely crafted wrench makes a barely acceptable hammer if you hold it wrong.

Given that most modern toolsets are backstopped by git repositories (or, if you're unfortunate, Subversion), git is increasingly central to DevOps tooling and design patterns. This talk covers a variety of common antipatterns commonly seen in git workflows, as well as advice on how to best avoid them, delivered in a humorous manner.

A (brief) selection of third party open-source tools for working with Git more effectively will also be showcased.

The formula to creating awesome docs

We all like to complain about bad documentation, but how many of us actually know how to create good docs? Quality docs are vital to the success of any project, and yet so often they're an afterthought. In this talk I'll show you very specifically how to create rock solid docs that your users will love. I'll cover the ideal layout, branding principles, design techniques, syntax highlighting, content organization and more!

The Hidden Architecture of the Domain

Often when talking about SOLID or architecture, the term "domain separation" is thrown around to describe how we should keep the framework logic separate from business logic. But what is actually inside of the domain? How can we organize domain code in a logical way? This presentation will give you some real world examples on how to organize your domain code with SOLID principles and provide some easy to follow guidelines for your own projects.

The Origin of HyperCard in the Breakdown of the Bicycle for the Mind

HyperCard was a programming tool for non-programmers that inspired much of the design of the early Web. However, much of the spirit of HyperCard -- the blurring of computer "use" and "programming" -- has been lost as the web has become a mainstream consumption-centric medium. This talk imagines an alternate timeline, where our tools have evolved to empower everyone and not just developers.

The PHP Package Checklist

Composer has changed the landscape of PHP. Gone are the days of massive kitchen-sink frameworks. We're now in the era of packages. And we can all contribute! This talk will walk you through each step of the PHP Package Checklist ( You'll learn how to properly package your PHP projects, ensuring they are taken seriously by the rest of the PHP community!

The Present and Future of WordPress's REST API

With WordPress 4.4 (released in December 2015) came the infrastructure to make creating REST endpoints in WordPress much easier. This was the first step to the project's goal of making all sites' content available via a standard set of JSON REST endpoints which finally let people abandon the project's historical XML-RPC endpoint. In this session we'll talk about what WordPress's REST infrastructure enables today, what that means for developers, and what the future looks like.

The Why Behind Frameworks

We all use and appreciate frameworks to help ease development, but do we ever stop to examine and understand the common design patterns driving them? We will work from a simple provided html site to build into something that looks very close to any modern framework and discuss the reasoning behind each step. Even senior developers should leave with something they didn't know or realize they knew.

Thinking With Immutable Objects

"An immutable object cannot be modified by accident." What does this statement mean in theory and in practice? What benefits do we see when using immutable objects for programming? Doesn't using immutability make it harder to develop applications? Where is immutability being used in the PHP ecosystem already?

This presentation will discuss the basic pattern of immutability and explain how to implement the pattern in PHP, as well as testing and mocking immutable objects.

Writing Workers For Scalable Applications

At some point in any successful web application's life, you're going to need to remove things from the request and response cycle in order to improve the performance. From sending out emails to publishing information to social media channels, we're finding ourselves trying to shoehorn more and more processes into the traditional HTTP request/response.

This talk will help explain how you can use a console based command line PHP to control workers that take and process jobs from a queue, helping to make sure each and every one of your responses is lightening fast. Using popular technologies like Redis and Beanstalkd to manage and monitor worker processes is a skill that every developer will benefit from sooner rather than later.

You Can UX Too: Avoiding the Programmer's User Interface

Programmers have a bad reputation when it comes to UX, but it's time to set the record straight: It isn't because we don't care! It's because we fall in the trap of thinking we can design a user interface and write it at the same time when, the truth is, these processes require different kinds of thinking. But learning how to unlock that part of your brain is worth it—and you'll be surprised at what you already know. From one developer to another, this talk will discuss why you should think critically about the interfaces you write and give you some strategies you can start applying right away, whether you're implementing on your own or working with a UX professional.