The following presentations are conducive to and have been given as a keynote. Most of them also work as regular-track sessions if desired.
Software Management Lessons from the 1960s
"The Mythical Man-Month" is one of the seminal books in the field of software project management. It was written in 1975, based on experience from the 1960s. Is it even still relevant?
Turns out, it is. Technology may have changed dramatically but people have not. Managing software projects is about managing people, not bits, and creative people engaged in intellectual endeavors are notoriously hard to predict and manage. (Just ask my project manager.)
Fortunately, many of the lessons-learned Brooks' presents are still relevant today. Some are directly applicable ("adding people to a late project makes it later") while others are valid with a little interpretation. Still others fly in the face of conventional wisdom. What can we learn from that?
This session will present a modern overview of the ideas presented by Brooks and a look at what we can still learn from them even today.
Free Software: It's not about the license
Free Software. Open Source. Software Freedom. Free as in Speech or Free as in Beer?
We're all familiar with the buzzwords, the catchphrases, and slogans. We all know the "GPL vs BSD" debate, and have probably participated in it at some point. But what do they mean, really? Is Open Source really just a friendlier name for Free Software, or is there something more to it?
Yes. Yes there is. Free Software, at its core, is a philosophical, cultural, and political movement. It is a part of, and inspiration for, the Free Culture movement. A movement born of a simple belief: That you should have control of your own digital destiny, and that it is immoral to deprive people of that right.
Let's try to recollect where our community came from, and the principles upon which it was founded.
General interest topics
These topics are not language-specific, and play well at most technical conferences.
The container is a lie!
Containers are all the rage these days. They’re fast, they make deployment easy, they handle dependencies, they slice, they dice, they make julienne fries! But... what are they? What exactly is a container and how does it work? Just how does a container differ from the “old” silver bullet, virtual machines?
Here’s a hint: It has nothing to do with boats, or whales, or shipping. That’s all marketing fluff.
Containers are simply a shorthand name for leveraging newer features of operating system kernels that let the OS lie to programs about how they’re running. In fact, all of modern software is built on lies. That’s what’s useful about it!
To understand how that works, why it’s so useful, and where it’s not, let’s dive into how software actually works on a modern Linux system to see how those kernel features fit into the big picture, building up to “containers” along the way. Pull back the veil of lies and see how your computer really works.
Building a cloud-friendly application
The days of hand-crafted artisanal servers are long over. Modern web applications need to be able to run on many different servers without code changes. Not just different hosting providers, but different environments on the same hosting provider. Whether you're using a legacy dev/stage/prod setup or a modern branch-is-environment host, modern hosting imposes some requirements on your application design but also offers a huge potential for new and powerful tools.
In this session, we'll explore some key guidelines for building a cloud-friendly application, as well as look at some architectural options that a modern hosting platform enables.
Why Open Source?
Open Source has largely eaten the Web. If you're working on the Web, you're using Open Source Software, somewhere. it's virtually impossible to avoid. That's because Open Source is a better, cheaper way to build software projects, and gets you lots of free help, too!
Or at least that's the myth. Is it true, though? What actually makes Open Source tick? Is it really better? Why? Why should organizations engage with Open Source, especially when it's supposed to be free, dagnabbit!
Let's take a step back and examine just what the benefits of Open Source really are, and why, and why Open Source is not a spectator sport.
The following talks are all PHP-specific; they'll play well at a PHP event, but likely not elsewhere. (But I'm open to it if you are.)
Never* use arrays
PHP loves its arrays. Arrays are the uber-data structure. They're a list, a map, a stack, a queue, everything in one! Which is the problem.
Modern PHP grossly over-uses arrays. In most cases there are better options today, and when you find yourself reaching for "oh I'll just make this an associative array", stop. An extra 60 seconds of thought and code will often give you a more readable, faster, more memory-efficient, more flexible alternative. Classes, iterables, and collections can and should replace arrays in most of your day to day coding.
This talk will go through what PHP arrays actually are (hint: they are not, in fact, arrays at all), why they're so problematic, and what to do instead. By the end, you should find yourself (almost) never reaching for arrays to solve a problem.
Exploring PHP 8.0
PHP's latest major release is a truly major release! (And tautologies are tautologies.) With more ease-of-use functionality than you can shake a stick at, PHP 8.0 promises to offer more power in less code than any PHP version to date.
Covering the whole of PHP 8.0's improvements would take a whole book (and has), but we can cover the major features in an hour. Expect code that is easier to write, easier to read, and more flexible than ever before in the web's premiere server-side language.
If after this talk you aren't itching to move your code to PHP 8.0, you're either asleep or not a PHP developer (so why are you here?)
PSR-14: A major PHP Event
PSR-14 is the latest specification from the PHP Framework Interoperability Group (PHP-FIG), this time addressing event dispatching. Many frameworks and applications contain an "event dispatcher", "message bus", "hook system", or some other variation on the same basic concept, but to date they are all incompatible with each other.
No more! The PSR-14 spec offers a way to interleave these disparate systems together, making it far easier to swap individual libraries into the framework of your choice. It goes beyond the basic "register and call" object that most systems use to make it easier to plug different implementations together, offering an easier experience and greater flexibility for library authors.
This session will cover how PSR-14 works, some examples of how to leverage it effectively, and how to adopt it alongside, and even encompassing, your existing one-off tooling.