A Gentle Walk Towards SOA

Many smaller projects with limited complexity can easily be served by an application written on top of your favorite monolithic framework. But as complexity and scope increase you will often find increased load times and significant barriers to testing by way of heavy coupling of both your application code and your data.

How do you approach this problem when you need to scale beyond the capabilities of a monolithic application? The concepts involved are rather simple and have been around for a very long time. But the path from monolithic application to a service-based architecture is not easy with existing projects. The answer is not to create many HTTP-based services tomorrow; the answer is to move iteratively through your codebase. In this talk we will look at how to approach this problem by teasing data and concerns into separated services in a step by step fashion.

API Pain Points

I've been building APIs for a long time now and it is becoming ever more common for server-side developer thanks to the rise of front-end JavaScript frameworks, iPhone applications and generally API-centric architectures. On one hand you're just grabbing stuff from a data source and shoving it out as JSON, but surviving changes in business logic, database schema updates, new or deprecated etc gets super difficult.

This talk will outline the common pitfalls developers get trapped in when building APIs and outline methods to avoid them, including POST/PUT/PATCH, data structures, embedding data in the response or sub-resource the URLs, sane file uploads, HATEOAS, how to utilize OAuth, etc.

Architecting the Madness: WordPress as a Modern Development Framework and Business

WordPress has a bad rap. Yes, it's deserved. The core architecture of WordPress reflects the period of its inception and its provenance as a blog engine. Recently, however, there's been a concerted effort to try and wrangle WordPress into a reasonable development environment. We'll discuss the tools and techniques that can be utilized to create an end-to-end development stack rivaling those found in modern frameworks like Laravel or Rails. This session will be especially poignant for developers engaging in medium to large scale WordPress development, or freelance devs who collaborate often or want to advance the efficiency and effectiveness of their workflow. Concentrating on solutions, we'll cover challenges including:

-- Library and Dependency Managment. There's plenty of information on how to utilize Composer, but what about commercial or third party plugins and themes? What if you could build a repository housing a self-updating copy of every one of your third party plugins or themes, allowing you to build a WordPress development project in seconds? We'll look at options like Toran and a private Packagist server.

-- Code Management. We'll cover solutions like Bedrock, a framework based on the 12 Factor principles that assists with proper code separation, asset pipeline, deployment and more. Best practices in a box!

-- Collaboration. Easily collaborate, onboard new devs and deploy your application, even with your private dependencies. Ensure code parity with all developers without keeping your entire project in git.

-- Concurrent Deployment and Scaling. WordPress is built out of the box for horizontal scaling, so why aren't we doing it more?

WordPress is still the biggest driving force behind PHP and a significant market opportunity. With these solutions, you'll increase your value and capability as a developer or agency, and bring some sanity to the chaos. WordPress doesn't have to be so bad!

Architecting with Queues for Scale, Speed, and Separation

You may know that queues can help with long-running tasks, but did you know they can help you make your application easier to debug, more performant, and scale in the cloud? Taking the real-world example of a contest app deployed on Azure, we'll see how easy queues can be to implement. You'll see how the smart use of queues can enable your application to handle many more users with the same code, break components across servers, and help you keep your app responsive.

Async PHP with React

Event-driven programing is a familiar and useful tool for crafting client/server apps and asynchronous libraries. Akin to Node.js or Python's Twisted, React brings PHP up to speed with all of the necessary pieces in a well-packaged framework. This session will introduce the concept of event loops, non-blocking IO, and async programming in PHP, and explore ways it can serve in your technology stack.

Behat+Mink+PhantomJS = Test ALL THE THINGS!

Sometimes simple unit testing is not enough. There is more to it than that when you want to test JavaScript and the rendering of your page. In this talk I will show you how you can use Behat+Mink+PhantomJS to accomplish screenshot comparison, test your JavaScript implementations and your PHP code using the same human-readable language: Behat’s Gherkin.

Behind the Scenes of Maintaining an Open Source Project

The open source world is made from human interactions as much as it is made of code.

During this session, Jordi will be sharing his experiences as the Composer Project lead. He will show you glimpses into what it means and feels like to be the maintainer of a popular open source project.

By sharing his experiences, Jordi hopes that you will gain a better understanding of the human factor in the open source community.

Building Extraordinary Packages

Back in the day, we had PEAR packages. These were often very well written, but due to PEARs lack of popularity we ended up just using mega-frameworks and writing bundles, modules, cells and sparks for that framework. Since then Composer has been a bit of a savior, but the way in which we make these packages is still new and scary.

There are a lot of talks about building good code, and writing OOP well, but how do you make a Composer package that is as high in quality as you can? Things like SemVer, avoiding NIH syndrome verses knowing WHEN to fork or make a new package, responsible deprecation and loads more.

The League of Extraordinary Packages is a group of developers who have banded together to build solid, well tested PHP packages using modern coding standards. The name might be a little silly, but the group dedicates itself to active maintenance, handing over projects when a lead has to step aside, working together and an absolute dedication to following and supporting standards.

Building Rock Solid Software in the Real World

As a professional developer, you already do all of the best practices. You store your code in a source control and write unit tests. You already know all of the patterns and when to use them. Your code is perfect and beautiful. Then you hire another developer. He puts his braces in the wrong place and uses different formatting then you. He keeps committing broken code to your code base. Then you add another two members to your team along with a junior developer. All of your beautiful code is getting ugly, brittle, poorly documented, and hard to maintain. We'll discuss some of the pitfalls and strategies when developing software in the real world, from style guides to code reviews to automated checks that keep your team from imploding in ego-driven angst.

Caching Strategies

One of the biggest bottlenecks in an application is the point at which data is requested from some source, be it a traditional database, web service, or something else. One method to overcome these bottlenecks is the use of caches to store pages, recordsets, objects, sessions, and more. In this talk, we'll explore a variety of caching tools and mechanisms including Memcached, Redis, reverse proxy caches, CDNs, and more.

Composer Best Practices

Composer has grown into the de-facto standard PHP dependency manager. While we struggle to make it easy to use, mastering dependency management and packaging in general remains tricky.

In this session you will learn how to leverage Composer version constraints, grasp stabilities and semantic versioning along with a few more tips on being a good OSS citizen. You should already be comfortable with Composer basics and eager to learn about it some more.

Debugging Zen

Debugging is one of those skills that developers have the hardest time exercising and is also one of the most difficult to teach. It is both a scientific discipline and an art. It often requires you to reach beyond analytical thinking to rely upon your own intuition in order to solve a problem. In this talk, we’ll examine how intuition plays a crucial role in debugging software. You’ll leave with practical pointers on how to tap into intuition as part of your debugging habits and how to combine it with analytical processes to be a better developer.

Dependency Injection, Dependency Inversion, and You

As developers we're told to limit the coupling of our code for testability, reusability, and a whole host of other reasons. Taking the time to understand exactly what Dependency Injection is and how we can accomplish it in PHP projects is important. Then we hear about the Dependency Inversion Principle and think we are okay because we are injecting dependencies. In this talk we will take a look at both dependency injection and dependency inversion from a theoretical and practical standpoint. Walking out of the room you should understand the motivation for practicing dependency injection as well as how the Dependency Inversion Principle can make your code more SOLID.

Deploying Web Applications with Capistrano

How do you currently publish updates to your code? How do you undo changes if you've made a mistake?

Manually uploading files via FTP can lead to mistakes or downtime and are difficult to roll back. Other techniques such as remote repositories or web/git hooks are better but can limit your ability to control the way updates are applied to the website.

Come learn how to streamline and automate the process of both deploying and rolling back updates to your web application with Capistrano, a remote server automation tool.

Does your code measure up?

After days, weeks, or months of coding many developers don't know how to test the quality of their code. Adam Culp will introduce tools to grade, benchmark, and analyze code in an automated fashion. So developers can write better quality software, understand what may need to be refactored, and highlight code smells or bugs before end-users discover them. Attendees will see how to use these tools, know where to find them, and be able to implement them in their own workflows.

Don't Fear the Regex

Have you been scared off by Klingon-looking one-liners in Perl? Do you resort to writing complicated recursive functions just to parse some HTML? Don't!

I'll demystify regular expressions and show you how best to do them in PHP. We'll cover the syntax and functions that make PHP a great text-parsing language, and give you the foundation to learn more.

As a bonus, I'll give you two cases people often use as examples for regexes that PHP gives you better native ways to accomplish.

Drupal 8: The Crash Course

One of the most widely-used and mature Content Management Systems on the planet, Drupal runs more than one in fifty websites in the world. However, it has always been something of an odd duck, with an architecture and design very different than anything else in PHP.

Enter Drupal 8: Almost a complete rewrite under the hood, Drupal 8 is a modern, PHP 5.4-boasting, REST-capable, object-oriented powerhouse. Now leveraging 3rd party components from no less than 9 different projects, Drupal 8 aims to be the premiere Content Management Platform for PHP.

But how do you use all this new-fangled stuff? This session will provide a walkthrough of Drupal's key systems and APIs, intended to give developers a taste of what building with Drupal 8 will be like.

Prior familiarity with Drupal 7 is helpful but will not be assumed.

Five things I wish they had told me before I started programming in PHP

Five things I wish they had told me before I started programming in PHP is a raucous romp through PHP, covering not only mistakes that programmers make, but skills they need to make sure they master.

This is a 101 level course. If you are new to programming or just new to PHP, you will get something out of this.

Functional PHP

Functional programming. Some see that term and think "functions? You mean procedural programming. I've been doing that for years." Others see it and think "you mean that crazy academic nonsense that no one understands? Pfft!"

In truth, functional programming is fundamentally an approach to software development, not a particular language or syntax. With PHP 5.3, it is an approach that is now more readily available and powerful than ever before. Even if you're not writing in Erlang or ML, there is still much to learn from the principles of functional programming to help write better code.

This session will discuss the history of functional programming and how it compares to other programming paradigms (procedural and object-oriented). We will then discuss by example how functional concepts and techniques, plus new language capabilities in PHP 5.3 such as anonymous functions can make our code more robust, maintainable, and bug-free. Even without a truly functional language, there is much we can learn from functional programming as a technique.

Getting Started with PHPUnit

By now, you probably know that writing tests for your code can save you a lot of time debugging, but getting a point where you are comfortable writing tests can be overwhelming. This tutorial will walk you through all aspects of testing including: installing phpunit, setup and tear down methods, assertions, data providers and mocking. We'll be walking through some untested code and learn how to lovingly wrap tests around some existing code. By the time we're done, you should have full confidence to start writing tests for your untested code.

Gitting Past the Basics

Having trouble groking Git? Not sure what the difference between merging and rebasing is? Wondering what you would ever use a "cherry-pick" for? We'll cover these topics and more in this talk, helping attendees get past Git novice and on their way to Git master.

We'll do a short review of git, then jump into branching strategies, commit amending, stashing, cherry-picking, and yes, merging versus rebasing. Okay, maybe you won't be a guru after one conference session, but attendees will have a better understanding of how to play nicely with others in the same Git repository and how to fix common (and not so common) issues in Git.

HipHop and Hack: PHP for Real World Applications

The HipHop Virtual Machine (HHVM) and the Hack programming language are ready stand ins to address performance issues in your LAMP stack. Join Nalin and Seth as we delve into getting started with HHVM, porting production applications over to Hack, performance tips and tricks, and common gotchas.

How To Make a Big Ball of Mud

In February 2012, I suddenly and without a lot preparation went from "PHP and WordPress hobbyist" to "lead engineer on a new PHP web app" when I started a small company with a friend. The resulting app is — with the benefit of time's perspective — a quite problematic mess, and in this talk we'll introspect into the mistakes that were made there, how we can fix them, and what the trade-offs of other paths would be. We'll cover some high-level values (separation of concerns, the trade-offs of frameworks, how to make things future-proof) to consider when architecting a sizable web application with concrete examples of why things go bad.

How to Speak at a Conference

Have you ever thought about giving a talk at the user group or at a conference but weren't sure what to talk about? Weren't sure how to format your slides? Weren't sure where to even start? Beth Tucker Long has spoken over 30 times in the last few years at various conferences around the world. Learn some tips for finding a topic, creating your talk, and engaging your audience. After the talk, Beth will be on-hand to work with you to develop your talk ideas, write your abstract, and find a call for papers or user group to submit your ideas to.

Introduction to OAuth Clients

Software development relies on integrations more now that ever before; a very important part of this process is the authentication and authorization with the products being integrated. One of the most common strategies for authorization and authentication is OAuth; it's also one of the most complex, misunderstood and confusing aspects of creating and consuming APIs. In this talk, we'll chip away at the mystery that is OAuth and take an in depth look how OAuth works and you can use it in your project.

It Feels Great to Iterate

Iterators are an awesome and important feature of PHP, and PHP comes with a lot of them built in too. Let’s talk about what they are, how they’re used, and how to make your own. Then we'll talk about generators, which is really cool PHP 5.5+ feature that takes iterators to the next level. And… we can’t talk about iterators without also discussing the Decorator design pattern. After all, most of the SPL iterator classes are decorators too. It’s never felt so great to iterate! May the foreach be with you! P.S. There will also be a special appearance by the @phpbard.

Logging, Monitoring, Security!

This talk gives an overview of how logging, monitoring and security are dependent on each other and covers the minimum stack that I recommend.

This talk includes real scenarios that my consulting company has dealt with or come across where these were not implemented correctly, how it could have been prevented or generally some words of wisdom for your own production environments in these cases.

Modeling APIs for legacy apps

"API first" is a great strategy for new applications. We can benefit from having a single interface for both our web and mobile presences and free up the developers to use the proper technologies where appropriate. Unfortunately, in the real world, most of us live and breathe legacy applications. The system was conceived long before APIs and we don't have the ability to just restart from the ground up. In this session we'll lay out a strategy on how to successfully model how to build APIs for legacy applications. More importantly, we'll work through the modeling process using a real world production application and index cards to describe each component and how they fit together.

Object-Oriented JavaScript (yes, it really exists)

What's that you say? You don't like working in JavaScript because you can't code like you want to with capital "O" Objects all over the place? Sure you can. More and more people are starting to realize how powerful this little language can be - start your re-education with this session and learn all about OOP in JS. First, we have to accept that while JavaScript may exhibit some characteristics of a functional language, it is really a multi-paradigm language with strong support for Object-Oriented Programming concepts.

This talk will give attendees a crash course in Object-Oriented JavaScript covering:

  • core OOP principles
  • the prototype object and constructors
  • member access types (public, private, & privileged)
  • prototypical inheritance
  • interfaces (mixins)

Developers will come out of this session ready to implement core OOP concepts in JavaScript, with knowledge of how inheritance in JavaScript differs from many of the other languages they know.

OOP Is More Than Cars and Dogs

When developers are introduced to Object Oriented Programming, one of the first things that happens is that they are taught that nouns turn into objects, verbs into methods, and Dog is a subclass of Animal. OOP is more than just turning things into classes and objects and showing that both Boats and Cars have motors, and that Dogs and Cats both speak(). Let's look at OOP in real world settings and go beyond cars and dogs, and see how to use Object Oriented Programming properly in PHP. Traits, Composition, Inheritance, none of it is off limits!

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

PHP Security Bootcamp

The web is becoming a more and more dangerous place every day. You, as a PHP application developer, need to be armed with the tools and knowledge to make your applications as secure as possible. Come get hands-on training in applying secure design principles, testing code for vulnerabilities and fixing the problems we find together. We'll be using a vulnerable application to illustrate some of the most common vulnerabilities like cross-site scripting, SQL injection and other notables from the OWASP Top 10 list. You'll walk away with a grasp of good secure coding practices and a platform for future experimentation.

Raiding the MongoDB Toolbox

Beyond your standard CRUD operations, MongoDB offers a potpourri of special features. Looking for a quick search API? Full text indexes have you covered. Churning through large amounts of data? Consider map/reduce or the aggregation framework. Querying geospatial data? Create a 2dsphere index and go to town. Digging a bit deeper, we'll look at a few techniques for creating backend services, such as event long-polling and job queue processing.

Refactoring Legacy Code

Faced with legacy code many decided to rewrite, thinking it will be easier, for many reasons this can be wrong. Adam Culp will talks about the entire journey of refactoring a legacy code base. We will begin with assessment and why, cover planning how and when, discuss execution and testing, and provide step-by-step examples. Attendees will gain insight and tips on how to handle their own pile of code and refactor happy.

Scaling Magento - Reaching Peak Performance

Building a cluster to support Magento is easy and makes a good example for scalable web application platforms.

I will walk through a typical Magento Cluster setup and provide Vagrant/Puppet configurations for the basic setup. Then I will cover some of the hardware and cloud resources that are required as the platform grows. We will move onto application choices, and some of the development, testing and deployment strategies that are required to have a successful clustered platform.

  • Hardware vs Cloud: Exploring hardware and software options available for scaling
  • Cluster Architecture
    • Web server: How to cluster your application
    • Varnish: How to speed up response time using reverse proxy caching
    • Database: How to cluster Magento Database using Percona
    • Redis: How to set up a Redis Cluster using Sentinel and Keepalived
    • Filesystem: NFS, NAS or other clustered file systems
  • Application Architecture: How to avoid angering your systems administrators
  • Testing: Exploring load testing with tools like Gatling and BlazeMeter
  • Development and Deployment Process

Serial legacy killer - My approach on going from legacy to modern

In this talk, I'll be covering a broad range of techniques that I've done in the past to help move companies from legacy systems to much more modern code.

This talk isn't just all about code refactoring because In my experiences there are many other battles to be fought along side with the code refactoring such as management, culture and team members.

Speak HTTP and Consume APIs with Guzzle

Guzzle is a HTTP client library in PHP that puts all the power of cURL at your fingertips, but with a simple and intuitive interface. Learn how to use Guzzle (version 5) to work with HTTP and web service APIs, and see how Guzzle's simple HTTP abstractions, flexible event system, and asynchronous request capabilities make Guzzle an amazing open source project that should be a permanent part of your PHP tool belt.

Stepping Outside your Comfort Zone: Learning to Teach

As a developer you spend your entire life learning. But what happens when the tables are turned and you become the teacher? Do you want to become a conference speaker, talk at your local user group, give presentations at work, or become a technical trainer? As a previous classroom teacher with a Master's Degree in Curriculum Development, I will take you on a journey to understand the various learning styles and how to effectively reach everyone. We will look at how to present your information, best ways to structure it, and learn ways to reach all students no matter their level. We will also cover a number of best practices for crafting your presentation decks themselves. Join me for this exploration into the inner workings of the human mind.

Talmudic Maxims to Maximize Your Growth as a Developer

You've been programming for a while now. You're beginning to feel that you've got a handle on things, but at the same time can't escape the feeling that you've somehow plateaued in your growth as a software developer. In this talk Yitzchok, a rabbinic scholar and software developer, shares the wisdom of the sages as practical, actionable advice strategies and tactics that you can use to reinvigorate your growth as a software developer.

Teaching Kids to Fail

During this talk, Maurya will speak about her experiences with working with students from low income communities, their difficulties with coping with failures in school and life, and how teaching kids to code can help mitigate some of fears students face when dealing with failure.

Testing the hard stuff: writing tests for things you can't test

When you need to fix or extend code that is 'far down the rabbit hole', most of the work becomes setting up the complex conditions to push the code to a certain point in the application flow. Instead, open classes up directly using testing harnesses, reflection classes and functional programming. Phpunit will be used to demonstrate code coverage before and after.

The Things Your Application Does While You're Not Looking

It's 2:00am. Is your application working properly? How will you know for sure when you wake up tomorrow morning? In this talk we'll look at strategies for effective logging, monitoring and metrics collection from within your application. We'll look at what kind of data you should and shouldn't log, and with what frequency, as well as some great open-source tools to use. We'll also take some first steps with Statsd and Graphite to help see trends in performance, user behavior, and overall application health. We'll also learn some useful ways to interpret the data we collect to get the best picture of what’s really going on when you're not looking.

Turning Your Code Into a Company: The Parts They Don't Tell You.

Somewhere around 2005 and 2006 my friend and I started tinkering around with building a better shopping cart experience because all the others sucked. Since 2007, we've processed over half a billion dollars worth of transactions and enabled thousands of online stores. It was really, really hard. This talk will tell the story of taking some code and persevering it into a company called FoxyCart. If you've ever wanted the liberty of being your own boss, hopefully you'll find yourself in this story and determine if you have what it takes to succeed.

Wax On, Wax Off: Coder Dojo

As software developers we tend to practice our craft in the way of doctors and lawyers rather than the way of athletes and musicians, failing to recognize the impact the trade offs and half measures dictated by many projects have on our growth as craftspeople. Code katas - deliberate practice, free of the pressures of "getting things done" - are an excellent way to strengthen our mental "muscle memory" and grow our craft. In this three hour workshop, we will examine the case for regular, deliberate practice and engage in guided, collaborative, hands-on learning designed to give you the skills to incorporate code katas and deliberate practice into your training regimen.

Your Inner Sysadmin

One thing that most programmers do not take the time to understand is the servers that their application lives on. Most know a smattering of Apache configs, PHP configs, and basic information about the OS. This talk will deal with looking at tools that can help you quickly set up a server and how it can help you be a better developer. We'll look at tools like puppet for server management, OSSEC for log management, different command line tools, and nagios/monit for system monitoring.