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.
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.
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.
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.
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.
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.
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.
"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."
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.
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.
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.
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.
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.
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.
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.
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.
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.
"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.
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.
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.
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.
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.
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 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.
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
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?
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 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.
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!
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!"
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.
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.
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.
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!
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.
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 (phppackagechecklist.com). You'll learn how to properly package your PHP projects, ensuring they are taken seriously by the rest of the PHP community!
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.
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.
"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.
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.
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.