Sunday, November 9 2014
10:00am - 11:00am
Are you comfortable writing modules for Drupal 7, but a little bit nervous to find out what you'll be facing in Drupal 8? This session is for you. The topics covered should be digestible by anyone who regularly writes modules for Drupal 7, but if you are still learning the basics things might move a bit too quickly for you. I'll be covering the new concepts introduced in Drupal 8 that you will be using most frequently. The focus will be on what you NEED to know to be effective and I'll do my best to stay out of the weeds of all the other cool possibilities that Drupal 8 opens up for you. Following a quick review of Object Oriented basics I will dive into: Configuration Management, Routes, Permissions, Annotations and Plugins. If you already have an existing module to convert there is https://www.drupal.org/project/drupalmoduleupgrader. In this session we will try to upgrade your brain so you can feel comfortable writing new D8 modules from scratch.
By now you are probably already using Drush 6 -- and if you are working on Drupal 8, than you MUST use Drush 7. Do you know what lurks inside these latest versions? Come and learn about the most recent changes.
10:00am - 10:30am
The year was 2013. The place was BADCamp. As I wandered from session to session I kept hearing about Vagrant, a free open source tool for creating and configuring disposable virtual environments. Shiny! But, I didn't know anything about it.
So, over the last year I challenged myself to learn to use Vagrant in Drupal core development and other projects. In this talk I would like to introduce you to working with Vagrant:
- What is Vagrant and why you might want to use it
- New vocabulary! what are providers, provisioners, boxes
- Vagrant and Drupal
- Common problems you might encounter when working with Vagrant and tips to make your experience with Vagrant better
- Vagrant resources
If you have used Acquia Dev Desktop or MAMP/WAMP/XAMPP and want a more flexible virtual environment for your projects, or are simply curious about working with Vagrant and want to get a solid overview, this talk is for you.
2:00pm - 2:30pm
In this talk, we will talk about how to use some off-the-shelf Drupal modules to make your site and the sensitive data within more secure. We'll cover the modules you need to keep your data secure, some principles around off- and on-site key management, and how to best use Two-Factor Authentication. We'll also discuss the limitations and liabilities involved in these approaches to round out the understanding of their applications.
2:30pm - 3:30pm
It is time for web developers to have a decent package manager. A way to define library dependencies, automatically distribute, download, and install them. Something that holds your hand, and brings you to a safe place, knowing that the components you're using are exactly what you need... Some of solutions include:
In this talk, we will learn to use each one, find each one's benefits, their pitfalls, and how they can work with Drupal. A the end, you will be empowered to use different package managers for your own libraries, allowing you to distribute packages and components across a a number of different systems. You will be able to automate your deployment system, and your life. Resistance is futile.
2:30pm - 3:00pm
Elasticseach is an up-and-coming open source search engine with a fantastic JSON API, scalable cloud-based architecture, and lots of interesting features. Until recently, there has not been Elasticsearch integration available in Drupal contrib.
Palantir.net has used Elasticsearch in two projects over the past year and a half. Both of these involved custom Elasticsearch integration, but the second involved customization on top of the Drupal contrib toolchain.
This session will start with the standard Drupal use case, and then introduce the Elasticsearch API, libraries, and debugging tools, and cover basic search concepts.
3:30pm - 4:30pm
New buzz word: "personalization first.” Tailoring websites to individual users boosts engagement and effectiveness, increasing sales, lead captures, etc. But challenges stand between you and great UX including: scalability, identification, data analysis and effectiveness. This session will present several personalization approaches using different methodologies and constraints. We’ll explain using known user traits, behavior, and analytics to avoid presenting irrelevant content to your users. Sometimes the results aren’t what you’d expect. Both anonymous and authenticated scenarios will be covered. Approaches include in-browser storage, external APIs, and native Drupal user accounts.
- How and where to use personalization
- Models and approaches:
- Identity-driven: Known user traits
- Behavior-driven: User activity
- Analytics-driven: Aggregate, historical data
- Demos and techniques
- Things to avoid and lessons learned
Talk originally given at the PNW Drupal Summit October, 2014.
3:30pm - 4:00pm
- Realtime & next generation of the web 3.0 (Single page apps)
- Realtime challenges
- The relevance for Drupal
- MVX Frameworks
- Realtime Utilities (Simperium, Firebase GRTA, PubNub, Pusher)
- Turnkey Realtime Stacks (BladeRunner, Derby, Meteor, Sails, SocketStream)
- Realtime Data Sync (esp Operational Transformation)
Saturday, November 8 2014
10:00am - 11:00am
The session will describe the basic concepts of routing and menu links in D7. Based upon that an introduction for module developers will be given, how they can integrate their modules with routing and menu links, local tasks and what not. Finally we get crazy and write a chuck norris module which kicks you onto a random site and other advanced stuff :)
Over the past year, Mashery took on Behavior Driven Development (BDD) style functional testing with Behat for PHP. BDD style functional tests have been gaining popularity due to their descriptive nature and coverage of real use cases. Writing reusable scenarios for use cases is quite a tricky thing. Steps need to be robust, to execute quickly, to speak to the use case and to handle errors cleanly. Achieving these goals is challenging. This talk will cover the philosophy this testing style and how to implement BDD style functional tests with Behat. This presentation/talk was previously given for the SF PHP Meetup Group, https://www.youtube.com/watch?v=ZsfppPy-sAI
10:30am - 11:00am
11:00am - 11:30am
We are used to thinking about Drupal as a CMS. But what happens when your awesome site starts scaling, and requirements fall beyond installing modules?
In this session I'll be exploring one of the features we love about Drupal: its extensibility. In particular, I'll talk about two cases:
- Doing custom development on top of Drupal's API.
- Harnessing third party APIs to bring new functionality, or just replace where Drupal falls short.
I'll go over some use cases, and in doing so, hope to broaden the view of what Drupal is capable of, and maybe blur the CMS line a bit.
1:30pm - 2:30pm
Welcome to the RESTful garage!
Get ready to get your hands dirty creating a high performance RESTful API with "off the shelf" components. We will evaluate existing tools, build our own, and then "race" the results to find a clear winner
With the rise of "headless Drupal" and the importance of structured content, its very likely you have heard of, needed, or wondered about building out an API for serving up your Drupal content. There are several fantastic module suites available now:
We will briefly discuss these, and their best use cases. Still, sometimes you just want or need to create your own...
Start your engines!
Hit the race track!
After we build a fast API, we will do some racing and performance testing to compare the results with the other major players. Expect some interesting results, and a solid comparison of the established solutions next to our custom hot rod.
Take it home!
All of the code and testing setup* will be provided so you can modify and run your own tests, as well as build out your own speedster for your own needs.
*fuzzy dice not included
Ever find a module that does 98% of what you need it to do, and there's no way to make it do that last 2%? Ever need to fix a bug in a module you've run into, but you're the only one who's ever had this problem? You need a patch.
Senior Developer Joshua Turton will cover the hows and whys of patching a module. You will learn:
- When is a patch appropriate?
- How to edit the module's code and what branch to edit against
- How to generate a patch with git diff
- Both on the command line and in a GUI
- How to report an issue in the module issue queue
- and how to name your patch file according to drupal's standards
- How to use drush make to apply your patch automatically.
- What to do if your patch is
- rejected (Oh NO!)
- accepted (WoOt!)
- And most importantly: Why you SHOULD contribute your patch, and don't be shy!
This session may include a live demo on a sandbox module.
About the Presenter
Joshua Turton brings a wide variety of skills to his role as a developer. A programmer comfortable working on both front-end and server-side technologies, he also brings a strong visual sensibility to his work. More than nine years of experience both in agencies and as an in-house developer give him a great flexibility.
Joshua has worked on a wide variety of projects, with an emphasis in the last few years on Drupal work. Highlights include the web site for the Federal Department of Energy and Pac-12 Networks.
A long-time Bay Area resident now living in Costa Rica, Joshua earned an MFA in Computer Arts/New Media from the Academy of Art University. He has also been an instructor there, teaching web technologies. In his spare time, he enjoys coaching Little League, board games, and chocolate.
2:30pm - 3:30pm
This session will walk you through some concepts and components behind Symfony 2, and explain how you can get started using them when working with Symfony, Silex & Drupal 8.
Some topics that will be mentioned on this session:
- What is Symfony
- The HTTP Lifecycle
- Request & Response
- Service Container
- Dependency Injection
- Events and Middlewares
- Third party libraries you can start using right now on the three platforms ( Symfony 2, Silex & Drupal 8 )
Drupal 7 is a powerful, robust tool that allows your site to grow in almost any way imaginable. But with this flexibility comes a learning curve. Drupal 7 has a reputation for being hard to use, harder to learn, slow, and only easy to develop if you know exactly what you're doing.
Don't get me wrong, those of us who do know Drupal, usually love Drupal, and we can become very efficient at using it to do a great number of wonderful things. We often love Drupal so much that we pour hours of our time, our hearts and often our souls into maintaining contributed modules, creating and posting patches, and helping others in the community.
But let's look into the future for a minute. Drupal 8 will probably be easier to use, but harder to learn. It will be slower to run (unless you have a beefy hosting environment), and completely different to develop code for. Developers for Drupal 8 are going to be more expensive, harder to find, and development time is going to be longer (initially) as long-time Drupalers learn the new systems, and as developers new to Drupal learn the Drupalisms.
Small to medium-sized businesses are already feeling the increasing costs that are associated with running Drupal websites. How much of the Drupal ecosystem is made up of these sites, the people who write content for them, and the developers who build them? How will they fare in a Drupal 8 world? How will that affect the entire Drupal ecosystem?
There's an alternative to Drupal 8: Backdrop CMS.
Backdrop CMS is a fork of Drupal. It splits from Drupal 8 very early in the development cycle, before the introduction of the Symfony framework. It's code is similar to that of Drupal 7 (meaning any Drupal 7 developer should be able to "get" Backdrop) but also includes features comparable to those in Drupal 8 including Configuration Management.
The primary goal of the Backdrop project is to decrease the barrier to entry. This includes lowering the system requirements (meaning more affordable hosting), making the interface easier to use, and making the code easier to learn. For Backdrop, the benefits of each significant change that's proposed will be carefully weighed against the cost of change.
Come hear more about Backdrop CMS.
We’ll show you how we designed and engineered a HATEOAS compliant API using Drupal 7, the awesome RESTful module, and a node.js client to interact with it. We’ll dig into this reference implementation and validate which best practices make things easier for the API Clients, and which ones are just hype. Thing’s we’ll discuss:
- What does it mean to be compliant with HATEOAS? What does this even mean?
- If your API is HATEOAS compliant are there libraries your clients can leverage, and what is that development experience like?
- Everything is a resource. Multiple endpoints to represent those resources, and actions attached to them.
- Do hypermedia best practices improve the client coding experience, and pay off long term?
- What API design decisions were the most important for good client coding experiences?
- How do you structure your API to provide compliant responses?
- What API design decisions are just hype and are things you shouldn’t worry about?
- API design tools.
4:00pm - 5:00pm
Goodbye hook_block_info(), hello Block Plugins. The Drupal 8 plugin system provides a set of guidelines and reusable code components that allow developers to expose pluggable functionality within their code and (as needed) support managing these components through the user interface. Understanding the ins and outs of the plugin system will be critical for anyone developing modules for Drupal 8. Blocks, field types, widgets, and views displays are just some of the places you’ll encounter plugins in D8. In this presentation Joe will draw on his experience working with Drupal 8 plugins in order to write about and help document the plugin system, and walk through:
- What are plugins and why, when, where are they used?
- How Drupal discovers plugins.
- Annotations and how they relate to plugins.
- Defining a plugin.
- Using plugin derivatives to allow for many instances of a single plugin.
- Defining new plugin types in your own module.
This presentation will be useful for anyone who will be writing new Drupal 8 modules or porting existing code from Drupal 7 to Drupal 8. It will help developers to better understand where plugins fit in the architecture of a Drupal module, and help to map your Drupal 7 knowledge about info hooks and callback functions to Drupal 8 plugins.
Drupal Commerce was developed from the ground up on Drupal 7, both benefiting from and contributing to the development of the Entity API, Views, and Rules modules. It redefined what Drupal can do in the eCommerce space, empowering businesses to sell physical products, event registrations, reservations, and digital products. Its ecosystem of contributed modules supports recurring billing with all of its complexities in addition to complex tax, multilingual, multi-currency, and omnichannel configurations. Moving forward to Drupal 8, we're reevaluating our feature set and architecture to make Commerce easier to use and to develop for. Starting with sprints at DrupalCon Austin and in Paris the first week of July, we began developing a generic set of libraries solving currency formatting, pricing, and address management to share with the rest of the PHP community. These libraries are then used by our Drupal 8 modules along with a fresh implementation of the various entity types and subsystems that make up the Drupal Commerce framework. In this session, you will learn about:
- The generic PHP libraries we are developing for handling currencies, price calculation and formatting, and address form building and formatting and our efforts to see them adopted by other PHP based eCommerce projects
- The key features of Drupal 8 we’re taking advantage of
- How changes to our architecture and user interfaces address the most common frustrations developers and merchants have with Drupal Commerce 1.x
- What Commerce 2.x is capable of today and how our roadmap compares to the Drupal 8 release schedule
Let’s talk architecture, look at a demo, get excited, and start bidding on our first eCommerce projects powered by Drupal 8.
As the PHP renaissance continues to change how developers work with PHP, Drupal has made significant strides toward adopting PHP’s new best practices in both code and interoperability. New groups focussed on the interoperability of disparate PHP projects have begun to get traction producing such standards as PSR-0 and PSR-4 while others work to model a reusable request/response layer. The interoperability awareness of PHP projects and frameworks has never been higher, and projects working to adopt and contribute to that interoperable future have an opportunity to contribute to the future standards of PHP in an unprecedented way. Drupal carries with it a significant existing install base, and componentization could lead to use in non-Drupal installs. Formally componentizing Drupal’s existing code base further and making individual components available to the non-Drupal world will spread our influence far and wide. In this talk I’ll elaborate on:
- Building PHP Components
- Componentizing Drupal
- The future of modules
- Component Interoperability
- Stack PHP & PHP FIG
- Expanding Drupal’s reach into the 80% of the web that is run by PHP
4:00pm - 4:30pm
There are buckets and buckets of API changes between Drupal 7 and Drupal 8. Which ones apply to your modules? How can you get a jumpstart on the porting process? How do you avoid carpal tunnel in making the same changes over and over (and over) again?
The answer is automated code scanning tools that notify you of API changes required and, where possible, make the changes to your code for you automatically!
- In Drupal 6, there was Deadwood (https://drupal.org/project/deadwood)
- In Drupal 7, there was Coder Upgrade (part of https://drupal.org/project/coder)
- In Drupal 8, there's Drupal Module Upgrader (https://drupal.org/project/drupalmoduleupgrader), because obvious names FTW. :P
This talk will explain the overall architecture of Drupal Module Upgrader, demonstrate how to use it on an example module, and then use the second half of the session time as a conversation with the core and contrib devs in the room about how to help fill in missing gaps/coverage.
5:00pm - 6:00pm
During this session you will learn about the concepts and components introduced on Drupal 8 and by the end you will have the basic knowledge required for writing a Drupal 8 module. - What is the Drupal 8 Console ? The purpose of this project is to leverage the Symfony Console Component to provide a CLI tool to automate the creation of Drupal 8 modules and other recurring tasks. This session will include a demo of https://drupal.org/project/console (what a live demo, but it's always a bad idea. Yes I know)