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.
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.
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!
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.
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.
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.
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.
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.
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 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 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.
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.
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.
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.
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.
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 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 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.
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.
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.
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.
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.
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.
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.
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.
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.
"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.
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!
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
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.