/Regex Makes Me (Weep|Give Up|(╯°□°)╯︵ ┻━┻).?/i

REGEX! Love it or hate it, sometimes you actually need it. And when that time comes, there’s no reason to be afraid or to ask for help from that weirdo on your team who actually loves regular expressions. (I’m that weirdo, fwiw.)

This session is geared towards beginning and intermediate regex users, and will cover topics using practical examples that you might encounter in your own projects.

  • What is regex? How's it work? A brief history.
  • Syntax, special characters, character classes
  • Grouping, capturing, and common gotchas
  • More advanced topics like: Backreferences; Passive groups; Lookarounds (my favorite)
  • PHP pattern matching and replacements
  • Regex in JavaScript, and js-specific limitations

Access Control Models: Controlling Resource Authorization

There are various access control models, each with a specific intent and purpose. Determining the ideal model for an application can help ensure proper authorization to application resources. Each of the primary models will be covered, including the MAC, DAC, RBAC, and ABAC Access Control models. Examples, challenges, and benefits of each will be discussed to provide a further insight into which solution may best serve an application. Application sensitivity, regulations, and privacy may drive which model is selected.

All the Laravel Things - Local to Production to Making $$

Laravel 5 has established itself as one of the best PHP Rapid Application Development Frameworks. Come learn about all the tools in the Laravel ecosystem designed to save you time and prevent you from writing the boring cruft you have to write for every application. We'll cover getting started with local development, building a basic application, and deploying to production. We'll cover how Laravel easily handles vagrant, testing, oauth login services, billing and subscriptions services through Laravel Spark, and deploying your application with services such as Laravel Envoyer and Forge to manage your servers.

Basic Database Programming for PHP Developers

So what does a database do with a query? How do you avoid the N+1 problem, SQL injection, or just poor database performance? If you are new to programming and want to learn how to efficiently learn how to use a database then you need to be in this session, You will understand how a database server processes a query, why you need to think in sets, why the common problems occur, how to filter user data, and get a very good overview of writing efficient database queries. This tutorial is designed to get novice developers started on the right path to working with a relational database.

Computers <3 Structured Data

Computers have one job: to read and process data. One job, and sometimes they still need help!

Structured data puts you in control, ensuring that search engines and other parsers aren't misreading your information. Get your events recognized as events, your business address as a location, and those product reviews working to attract customers!

Implementing good, structured data is also the first step into the Google Knowledge Graph, the Holy Grail for content marketers. Better yet, with modern standards, it's easier than ever before to get started!

Containerizing PHP Applications

Lets face it, Docker is hot right now. If you’re itching to get started but aren’t sure how, you’ve come to the right place. In this tutorial, we’ll spend some time going over basic Docker concepts like Dockerfiles, containers, images and registries. Then we’ll look at some sample applications including Wordpress, Drupal and some framework-based examples and talk about strategies for building Docker images for these various different scenarios. We’ll also cover how to handle external dependencies such as file storage, databases, caches in both development and production environments.

Contextual Communication in a Connected World

Communication is critical to the success of modern. With the rise of smart homes and smart cars and even smart toasters, it's time for smart communication. In today's connected world we shouldn't have to navigate complex phone trees just to reschedule a flight. Imagine a customer support rep that already knows the problem you're facing before you even call. Context is key and our apps can provide the context to both sides of the conversation. This pain-free communication is achievable today. You'll leave this session knowing not only why but how modern communication will transform business forever.

Curing the Common Loop (with Collection Pipelines)

Trying to understand a complex function full of nested loops and conditionals is like trying to read a "choose your own adventure" book from front to back.

In this whirlwind tour of programming with collection pipelines, you'll learn how to use functional programming ideas to break down complex code and abstract hidden duplication behind expressive higher order functions.

Together we'll refactor ugly, complicated spaghetti into a series of simple, elegant transformations; free of loops, complex conditionals, and temporary variables.

Never write another loop again.

Discovering Dark Knowledge in the Social Web

It used to be that crawling social media required some creative coding, a deep understanding of links and relationships, and a finely tuned BS detector. With machine learning becoming common place, it turns out you only need the first two.

Considering information in isolation never gives us a complete picture. As we supplement what we know with what we discover with what inferences and patterns our models can detect, what we know and what we KNOW becomes starkly different.

In this session, we'll dive into a multi-year project that has used social media and other public data sources to uncover hiring patterns, stealth startups, and even pending legal action.

Dockerize your unit tests for faster feedback

Ever got the message "Fatal error: Out of memory" when running your unit tests? Or do you have to wait for more than 5 minutes for all of your unit tests to complete? We're using Docker to mitigate these and other issues. In this session I will show you how we have split up a single testsuite of 3K+ tests into manageable unit modules which are executed by Docker micro instances in parallel. And with this set up we test our application on the current PHP version, but it also allows us to test against a new major PHP version the moment it is released or even is available in beta.

Double Loop: TDD & BDD Done Right

Do you TDD or BDD? Why not both? Come learn the "Double Loop" workflow and discover how you can use both Behavior Driven Development and Test Driven Development to write well designed, tested and documented code. In this tutorial, we'll create a small application using PHP, Postgres and Javascript, fully designed and tested with Behat and PHPUnit.

Effective Browser JavaScript Debugging

Did you know that your web browser has a full suite of built-in JavaScript debugging tools? With the developer tools in Chrome, Firefox, and Safari, you can debug JavaScript on the fly with breakpoints, watch expressions, an interactive REPL with autocomplete, and much more. Learn how to troubleshoot bugs and memory leaks like a pro, armed with the same web browser you already use everyday - no extra plugins or downloads required.

Effective Code Review: What to Say & How To Say It

Reviewing your peers' code is a critical part of working on a team - it helps prevent bugs and can give you understanding of parts of the application you haven't worked on. The key is knowing what to look for in a code review - and then communicating your thoughts in an effective way. In this session, we'll look at example PRs and practice reviewing them to get the best results.

Getting Git

Version control is a must for development. With the popularity of services like GitHub, Git has become the top choice for version control. However, not everyone is as familiar with Git as they might want. In this talk, we'll explore everything from 'git init' to 'git bisect.' Through live demos we'll apply what we've learned to tackle everyday scenarios using Git. So whether you're just starting out with Git or a Git pro I guarantee you'll learn something.

Groupies, Roadies, Rockstars

Contribute to Open Source!

Everyone tells you that you need to. What if you don't want to run an Open Source project? What if you just need something to work? What if you just want to use Open Source, can you still make a contribution? Of course you can!

In this talk we will look at three broad groupings of roles that you can play in any Open Source project. Take a look around, find your role and your project and make a difference.

How I Learned to Stop Caring and Made Better Software

Best practices are important, but are they always the best for your situation? I spent years working on large software projects where best practices were crucial. Milestone planning, multiple code branching, 99.9% uptime requirements, heavy testing, deployment processes, etc. But I then blindly applied those to every project afterward. In retrospect, that hurt many projects, especially in smaller companies and startups where the speed of innovation was more important and downtime acceptable. In this session, learn from my experience and discover where cutting corners is not only acceptable but better for the project. At the same time, determine which practices are crucial and should be used no matter what!

How to Communicate Effectively Despite Technology

Today’s society is filled with devices, apps, and software that make communication easier and faster. But are we communicating with others in the most appropriate and effective way? Are we causing more problems and headaches for ourselves by only communicating in 140 characters at a time? In this talk, we will discuss the elements of interpersonal communication, the pitfalls of various methods of communication, and learn tools and strategies to put into immediate action. Attendees will leave with six action items to immediately use and improve their communication.

How We Changed The World With Open Source

In June of 2012, podcaster and veteran web dev Ed Finkler spoke openly about his lifelong struggles with mental illness with co-host Chris Hartjes. Four years later, a non-profit corporation with a dozen volunteers is working to change the tech and open source community. In this talk, Finkler tells the story of how the episode happened, the incredible response they received, and how it grew into a charity dedicated to changing and saving lives -- all by using the principles of open source culture.

I'd Like to Write the World Some Docs

It takes a special kind of person to enjoy writing documentation; not only do I have to write [ideally] working code, but now I have to write words that a human being can understand? What is this madness?!

Luckily, good documentation lives on outside your codebase. By following common documentation standards, we can generate comprehensive manuals that instruct others how to integrate with our software. After all, to code is human, but to document is divine.

Introduction to Graph Databases with Neo4j

Graph databases are all the rage these days, but the ideas they’re built upon are hundreds of years old. After a brief look at the history of graph theory and its practical applications in Computer Science, we’ll dive right into Neo4j - the world’s most popular graph database! Learn the differences between a graph database like Neo4j and your traditional RDBMS. See how to model your application’s domain using the new concepts available to you and how to query your graphs using Neo4j’s intuitive query language, Cypher. After this talk, you’ll agree that (Neo4j)-[:IS]->(Awesome) and be excited to use it in your next web application!

Irritating Strings and Iterating Things

Arrays are beautiful in PHP. One can map them, reduce them, filter them, foreach them, and use them in generators. Strings, on the other hand, are mere shadows to the Array. One can, uh, input and output Strings, and, when brave, manipulate them. What makes Arrays so awesome and Strings so dull? Iterators.

In this talk, we’ll look at the modest origins of the String and the basics of the Iterator. Then, we’ll look at how we can make the String as awesome as the Array through the use of iterator interfaces.

By the end of this talk, you will know the origins of the PHP String and you will be able to extend your knowledge of iterating through a String to be able to iterate through customized objects.

Job Queues with Gearman

When higher traffic coupled with costly operations begin to degrade your site’s performance, an asynchronous job queue can be a valuable tool to help relieve the stress. With Gearman, PHP developers can easily farm out non-time-critical jobs like image processing, external API requests, and complex data processing operations to a pool of workers better suited to the task, leaving their webservers free to continue serving requests.

Join Michael Moussa as he walks you through the basics of setting up a Gearman job server, writing clients to communicate with it, and creating workers to do the heavy lifting. After the basics are out of the way, he'll go into some pitfalls to watch out for when working with Gearman, as well as some tricks to make development easier.

Learn to Stop Wiring and Love Laravel's Container

You've heard about dependency injection and inversion of control. Everything seems easy at first and you've found a container or two to help make your life easier. Until it isn't anymore. Suddenly you've found yourself managing complicated YAML, XML, or PHP container configurations. Making any change to your classes dependencies seems like a chore and any time you add a new class to the system you dread the inevitable configuration container configuration wiring blues.

Life doesn't have to be this way! In fact, life isn't this way for anyone who uses an autowiring container like Laravel's. Far from the most publicly marketed component, Illuminate\Container handles a lot of the magic that makes Laravel so much fun to use. Find out how you can use Laravel's container in almost any project! See how autowiring can free your mind from having to manually configure ever little dependency. Learn how you, too, can learn to stop wiring your dependency injection container and love Laravel's container!

Learning Machine Learning

From chatbots to your home thermostat, it seems like machine learning algorithms are everywhere nowadays. How about understanding how this works now? In this talk, you will learn about the basics of machine learning through various basic examples, without the need for a PhD or deep knowledge of assembly. At the end of this talk, you will know what the Naive Bayes classifiers, sentiment analysis and basic genetic algorithms are and how they work. You will also see how to create your own implementations in PHP.

More Than Just a Hammer

Learn to expand beyond just PHP to integrate other languages into both your personal skill set and the solutions you deliver.

In this talk we'll cover integrating JavaScript (frontend and backend via node) and how you can expand your current skill set to include this or any other language alongside PHP.  The old saying, if all you have is a hammer everything looks like a nail, is very true so let's learn how to use a wrench and maybe a chainsaw!

Not only will this give you another tool in your tool belt, it will give you a greater understanding of development practices and the ability to on new jobs, new projects, and new challenges.

MySQL: Analysis, understanding, and optimization of queries

Your new database query ran quickly when you tested it, but seconds after deploying it, alarms are blaring, and you're scrambling to rollback before the site goes down. What happened?

I can "EXPLAIN."

Queries that perform well under development load with limited datasets can easily bring a database to its knees under production load. In this talk, you will learn to decipher query execution plans, recognize portions that can be improved, and take the necessary steps to optimize your queries!

Practical PHP Deployment with Jenkins

Developers would love to "automate all the things", but where do we start? What tools exist for automating? And what can actually be automated? If we don't have unit tests can we still benefit from deployment automation? Adam Culp will show how a PHP application pulled from git, complete with unit tests, Composer dependency management, and package creation, can be deployed flawlessly using Jenkins. Then see how "Dev" and "Ops" are supported by a system if the application breaks through automated rollbacks.

Problem Solved-ish

Your customer calls, your project manager assigns you an issue, your open source project gets a pull request, or your boss emails you – “There’s a problem…” As computer genius and wiz kid you are expected to solve all of these problems because that’s what you are – a problem solver. Well, sort of. Kind of. Not really. Software engineer, sure. Frontend developer, yep. But when was the last time someone gave you a complete, perfectly described problem and you solved it completely? Do you even remember being taught how to recognize, describe, and solve problems? How do you even know if it is really solved?

In the talk Problem Solved-ish we learn again or perhaps for the first time how problem solvers think, how our skills our empowered by our knowledge and understanding of the problem itself, and how solutions finally reveal themselves and the problems really do get solved. We take a look at the five C’s of debugging. We show the five Q’s of the Problem Solving Method. We demonstrate how testing can improve your confidence, your problem describing skills, and even your solution making skills. We will explore the business angle of problem solving and optimization by constraint based decision making and problem solving. Finally you will have a framework for making sure that it’s “problem solved.”

Projects are not Products

If you build it, they will come.. well no, not really. Not even close.

As developers, too often we believe the best tech wins. We want to believe customers care about clean code, the most features, and our architecture. It turns out, no one cares.

When we’re building products, we need to understand the problem we’re solving, who we’re solving it for, and how to reach them. In this session, we'll review concrete steps and discuss how to turn your project into a product.

Pulling up Your Legacy App by its Bootstraps!

Your mission, should you choose to accept it, is to support an application built on an older framework. Refactoring isn't an easy option. The code is untested and nowhere near best practices or standards. In this session, we'll talk about strategies to incorporate modern PHP coding practices to add features and functionality and retiring the older code in pieces. We'll review specific examples and code from a real project where we bootstrapped a legacy application that needed a lot of help to become useful to its users and simpler for developers to maintain. We'll talk about strategies to leave the existing code in place until the new code is ready to replace it in whole or in pieces.

Put an end to regression with Codeception Testing

Ever kill a bug only to have it resurface later? How about that last intermittent bug you had to trace down? Looking forward to fixing it again when it pops back up?

If you hate reanimated bugs then this session is for you. In this session, we will discuss the why and the how of building regression testing into your tests using the Codeception testing framework.

Join me, let's hunt some zombie bugs. (Weapons not required)

Real-time Dashboards With Async PHP

When having the critical information available in an instant, businesses look to develop real-time dashboards and data streams. You’ve heard of websockets and everyone knows there is and Node.js but what if you could do it all in PHP? In Real-Time Dashboards With Async PHP we demonstrate how to write an event loop and then create non-blocking code which can communicate bi-directionally with one or more connections. We will write up a responsive web interface that can provide real-time stats as a reactive dashboard. While an advanced topic, we will build up from the entry-level sparing no details or introducing any magic along the way. At the end we refactor utilizing a few abstractions which make our maintained codebase smaller and finally replace the plain-vanilla JS dashboard with a frontend view framework (Vue.js) to help with the client-side heavy-lifting. The result is a synchronous and asynchronous bridge that makes frontend and backend communicate as a seamless evented application.

Rise of the Nodebots

So you’ve finally managed to build a full stack application, all in Javascript. But what if your hardware programming could be done with Javascript too? In this introduction to Nodebots, you will learn how to use NodeJs to build a robot using an Arduino board. Well, maybe not a full robot but at least a blinking LED. You will learn how to add basic sensors and other general electronic components and you will learn how you can do it by yourself, at home, on a minimal budget. Come to this talk and you too will be able to contribute to the Robocalypse.

Serving 30,000,000 Requests an Hour in the Cloud

You've written an application and now the worst thing that can happen to you has come about - People are using it! You now have load spikes to deal with. You can scale up to deal with the excess traffic, but what do you do when your load is variable? How do you do that, and stay on budget?

This session is a case study on getting an App Engine app to scale to serve 30,000,000 requests an hour. It will take you through the architecture, the code changes and the technology trade offs to get to that level of traffic.

Smiling From the Wrists Down: Customer Service for Developers

Are you an experienced developer that is now in charge of other business tasks maybe as part of a small business or startup? Customer service can be tricky and leave a lasting impression. Come learn from first-hand experience what to expect, how to answer the question that is meant- not the one that is asked, and how to effectively communicate with your customer and achieve a better outcome for all.

Static in the Front, Dynamic in the Back!

PHP may have some more type hinting abilities than it has in the past, but it's still a very dynamically-typed language. It's an ecosystem in which we are all comfortable. But what about those times we are called upon to build the front end of a new single page application? JavaScript isn't syntactically too far off from the PHP we know, but it is a very different beast. We may very well shoot ourselves in the foot if we accidentally return undefined...or was it NaN?

Maybe this would be a great time to check out Elm - a statically typed, purely functional language that compiles down to JavaScript. Not only will the compiler guarantee our code be free of runtime exceptions and type errors, but it will also provide the kindest, most helpful debugging hints and tips you've ever had the pleasure of reading. Elm frees you up to think about modeling your business logic and having fun while writing code, rather than worrying about what framework you should choose, how to structure your application, and other exhausting choices.

Come see a fast-paced introduction to Elm. We'll walk through some of Elm's most notable features, what the Elm Architecture entails, and learn how to model and implement a simple application with using static types and a functional mindset.

Status Change: Now Using Event Sourcing

Being flexible to changes in business process makes our jobs easier, and it helps our applications adapt to those changes with minimal code changes. One of the biggest adaptions in our applications has been the addition of Event Sourcing to make a note of an Event that happened in the system. With these Events, we can affect change immediately, or even later. This is most helpful in our reporting interfaces. We can build, change, and throw away our reports very easily. This is much easier than our older reports being generated by large SQL queries.

Attendees will learn: - idealogical differences between status flags and events - triggering events in your application - handling events to reflect the state of your application data - building reports from events that are easy to change

Stay Nimble by Rolling Your Own PSR-7 Framework

PSR-7 is ushering in a new era of interoperability in PHP. This also means that there are a lot of complicated choices to make when deciding how to build a "PSR-7 application." Which framework should you use? Do you need to write your own PSR-7 implementation? Should you choose a microframework, a full-stack framework, or roll something of your own?

To help answer some of those questions you'll be introduced to a light PSR-7 framework named Nimble. More than just a sales pitch, explore the reasons for rolling your own framework, how the third-party components that make up the core of Nimble were selected, and how the pieces all fit together. Walk away knowing that PSR-7 frameworks aren't as scary as they look and that creating one yourself may be the best idea of all!

Test Driving Test Driven Development

We've all been to the talks about the tools for test driven development. But TDD is not just about writing tests, it's about driving development through testing. There's a very specific process of TDD with red, green, and blue phases. There's also different patterns, like outside-in or inside-out. In this talk, we will focus on these practices by TDDing a common data structure from start to finish. Attendees will gain experience and leave with tips to help them practice TDD in the real world.

Tests Should Tell a Story

PHP has been adopting testing on a wider scale over the past several years, and it feels like we're finally at a point where we can start to sharpen our skills and tools, rather than rallying to see any testing at all. At this point we should start ensuring that our tests tell the story we'd like them to.

Through an analogy of storytelling, this talk aims to help you be the hero of your testing story by giving new context and perspective to the way a test suite should read to both your colleagues and your future self. We'll demonstrate how proper naming and assertions can lead to simpler, faster debugging. We'll also see how an end-to-end test has a far more compelling story when you focus on describing the feature and business goals over describing a specific UI workflow in painful detail.

The Accidental Professional

Humans learn most effectively through pain, like being shocked by a power outlet or touching a hot iron. The same reaction can be found in technology, but how can we attribute this to programming while minimizing the most painful mistakes? Adam Culp will share his experiences of the ongoing journey to become a professional developer, and highlight techniques used to reduce the pain and still reap the benefits. And for those times when the pain is inevitable, how can we fast-forward to enlightenment.

What WordPress Teaches Us About Software Ecosystems

WordPress is almost certainly the most successful PHP software in the world. And that success is not — though some might joke that it is — an accident. In this talk we'll examine what WordPress has done right and what that can teach other software. We'll also talk about some of WordPress's problems, and understand how they mirror those of other large open-source projects.

You Don't Node.js (or, How JavaScript Actually Works)

JavaScript and Node.js can be a powerful tools used in the right situations, but they also have more footguns than PHP does for new developers. Asynchronous programming style, concurrency issues, error handling, the event loop, and no default timeouts for HTTP requests or network calls will give new developers more than their fair share of troubles and can cause issues that are difficult to debug and reproduce.

This talk gives a brief introduction to Node.js and the event loop model (don’t block the event loop!), and covers common pitfalls when using Node.js with simple and practical solutions.

Your API Is Bad And You Should Feel Bad

Do you hate the Facebook API? We all do as well. So stop writing your API in their footsteps. In this talk we will walk through how to construct a RESTful API, what makes an API your users/developers will love, and why you should eat your own dog food with API Driven Development.