Session Schedule

Saturday, November 8 2014

9:00am - 10:00am

10:00am - 11:00am

Last year, Facebook switched 100% of its production servers from a PHP to C++ compiler to our own virtual machine, HHVM. Since then, HHVM has gotten a further 2x faster, and now supports a huge number of PHP frameworks and extensions out of the box.

This talk will go through:

Our current capabilities (frameworks and extensions)

How we differ from standard php

Getting HHVM up and running

The exciting additional features available only in HHVM (spoiler, there’s lots)

Continuous Integration (CI) is the practice of successfully smashing bits of code together to make a finished product. That's it. This means using version control to manage your bits. This means testing your application throughout development, as opposed to leaving it until the very end. (Or testing it on production. This means actually communicating with your teammates and the clients throughout the process. Yes, yes, there are cool toys like Jenkins and Selenium and Mink and more serious must-learn skills such as PHPUnit and I will help demystify them for you. They all have their place. But Continuous Integration is an approach to development, an approach that we hope to get you excited about for the first time or all over again. This talk is an overview of the practice of CI, how it does applies to Drupal, and why you can't properly deploy a site without it. I will talk you through all the requisites, the low hanging fruit, the cool toys to help you refine this process. We will do this all with an honest look at how we implement CI at Promet Source and the lessons we learned and the dead-ends we found along the way. This is a talk for the technical and their bosses (especially the skeptical ones). Topics include: What is Continuous Integration? Why you must stop what you are doing right now and implement its practices. All the cool things you can do when those practices are in place. How you might go about implementing CI yourself. Right now. How you might refine and further tune your CI practice. What we are doing with BeHat, Travis CI and how it made us developers and our sites so much better.

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 :)

Maps are all over the web these days, and they can be extremely effective tools for finding and sharing information. Embedding a simple Google Map is easy, but what about building something that is more integrated with your content?

It turns out you can build awesome integrated maps in Drupal almost entirely with point-and-click tools: all you need is the Open Source Leaflet library, Views, and a few other Contrib Modules. In this session we'll show you how by interactively building a site with a map from a bare Drupal 7 install.

Participants will choose what type of mappable content to create, and will be asked to add content using their own devices to build a rich demonstration of the map's capabilities.

As we assemble the required modules and configure our site, we will discuss the roles played by each module without a bunch of geospatial techno-babble.

By the end of the session, we will have an interactive map displaying content that is easy for any site user to input using address data. If there is sufficient time, we will discuss how to customize the map's "tiles", add plugins, use proximity filtration, and other potential features for your map!

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

This session is for people who are relatively new to Drupal and would like an orientation (or refresher) on the concepts, jargon and community involved in learning Drupal.

We’ll introduce All the Big Things at a basic level. Attendees will come away familiar with the Drupal landscape and with recommendations for specific sessions to attend to dive deeper into key concepts and particular topics.

(Self Promotion) - In my (non-technical) role, I've facilitated and led dozens of Discovery sessions throughout numerous industries. Jenn (Ideaseed - more technical than I), has also led many. Humbly, we don't believe the discovery methodology we use to be single way, but we do profess it to be effective as it has led to many a successful implementation. We'd like to share our learnings.

10:00am - 10:30am

There’s no denying that a designer’s role is changing. Responsive Design has made the whole process much more complex. Designers are now expected to be equal parts artist and coder, and to use HTML, CSS & Javascript as their palette. I’ve met that challenge, and I‘ve spent the last few years working on several large, responsive Drupal sites. This talk will include a candid, real-world look at my personal evolving design process, as well as lessons from my own personal journey as a designer.

10:30am - 11:00am

JavaScript can be an unwieldy and scary beast if left untamed. Don't leave it untamed. Writing maintainable and extensible JavaScript is important. This session is for those: * curious about modular JavaScript * curious about testing JavaScript * brave enough to face the JavaScript Beast. * who desire inner-peace. * who seek elegance. You will learn: * How to modularize your JavaScript code. * How to test your JavaScript code. * Some automation techniques for the above. Included with this session a template module that implements ideas in the talk to get you up and running in a jiffy. That's right. A jiffy.

11:00am - 12:00pm

Every week brings a new example of a breakdown at the nexus of technology and trust. Whether it's vulnerabilities like Heartbleed or mass violations like the Snappening, the broader public is growing more and more cynical about whether tech can be trusted for personal data and activities - all at a time when it's becoming nearly impossible to do otherwise. Do we just write this off and say goodbye to democracy, privacy, and freedom of expression? Or can we, the toolmakers, figure out better ways of working as a community of Open Source communities, to restore the confidence every citizen deserves in the tech they depend upon? To restore their digital sovereignty?

About the Speaker

Brian Behlendorf, of Mithril, EFF, Mozilla, Benetech, is a technologist, computer programmer, and an important figure in the open-source software movement. He was a primary developer of the Apache Web server, the most popular web server software on the Internet, and a founding member of the Apache Group, which later became the Apache Software Foundation. Behlendorf served as President of the Foundation for three years. Behlendorf has served on the board of the Mozilla Foundation since 2003, Benetech since 2009 and the Electronic Frontier Foundation since 2013.

Yeoman is a powerful scaffolding tool, but we often only think about it to scaffold out a website. But Yeoman generators can be written to scaffold out just about anything, from common CSS files to advanced Sass partial structures! In this session, we'll go over how to create a Yeoman generator of your very own, how to integrate other generators, and how to use Yeoman for more than just scaffolding out full projects.

This session is designed for both the beginner and intermediate site builders. Since Views is the second most popular Drupal project, I am sure that everyone is familiar with it. But, have you mastered all that stuff in “Advance” column? What is a contextual filter and how do you use it to your advantage? Can you display field from other related entities in your view? What does that “Use aggregation” field do? Have you ever wanted to have a view ask for the filters before it runs the query?

This sessions will explain what these "advance" settings do and how to use them. If we have time, we will also discuss how to:

Make a table view responsive

How to download your table views to a CSV file

How to implement conditional fields and fixed text on a view

Update a field in multiple nodes at the same time from within a view

The answer to these questions and more will be revealed during this session.

Usability testing can help bridge the gap between developers, marketers, and stakeholders. Usability testing lets the design and development teams identify problems before they are coded. The earlier issues are identified and fixed, the less expensive the fixes will be in terms of both staff time and possible impact to the schedule. Usability testing is a great way to help teams prioritize website redesign efforts. In this session, we'll talk about the main types of usability tests and why it's better to usability test before deciding on making changes to the design. By conducting tests early, your team learns what to change. You'll learn what to keep. Usability testing early makes it easier to build the requirements, define the use cases, and even create QA test scripts, because you can drive all those things right off what you saw in the research. It will likely reduce your development costs because you’ll have data to make decisions, instead of driving everything off some strong-willed individual’s opinions of what users need. Pushing your user research as early as possible in the schedule is the best way to get value from your efforts.

Want to build a site, but are confused by what Drupal means when it says Node, Block, or Page? Learn how to talk with the friendly Drupal robot using language it knows. Win PRIZES! Become an ambassador to the world of machines, and build even better Drupal websites!

We will:

define some of the most confusing Drupal words

explore how these words relate within our Drupal site-building universe

draw a big picture (or Model) of that universe

learn to translate our world into chunks of data that can live in Drupal-Land

This session uses NO CODE and is designed for Beginners, but people of all skill levels and interests are welcome. Come help make our Drupal world easier to understand!

While this may look like a confessional, this is a collection of 'worse practices' that I have either seen, done myself, averted at the last minute, or gotten to watch them go down in flames. This will also skew heavily towards back-end problems that project managers get to face, because it's where I'm most comfortable and have the most interesting stories. Audience participation encouraged.

I'll cover:

Sales disasters that ended up making it into my life and never should have been here

Discovery disasters that ended up making people crazy

Methods of project management applied too vigorously and took the shine off everything

Communication methods that ended up worse off than just saying nothing

Ways to work 70 hours a week because you're just so valuable and no one could possibly do the same things that you do (So flexible!)

1:30pm - 2:30pm

We must get the content to the user, and we must do it fast. In a world constantly moving, getting a site loaded in under 1000ms is key to keeping users on your site, and engaged with your content. This is not a new idea, and the 1000ms barrier has been written about, presented, talked about in web circles for a while now--- but how do we actually do it?

Working on a Drupal site, how can we decrease bloat on a page, to get our site delivered to the user quickly and efficiently. What steps can we take to decrease that first hit, so a page is available as soon as possible, especially for a mobile user.

This talk will go over the tech, and the basics of the TCP protocol so you understand where the lag is in presenting a web page. It will describe the modules any frontend developer can use to help in presenting their content, and frontend techniques that can be applied by advanced themes to make your site the fastest on the net.

The goal of this panel is to discuss things that we in as men and women in tech can do to help all women feel welcomed, safe and appeciated for their professional accomplishments.

Please contact @matt2000 / matt [at] chapman media .com if you'd like to participate in the panel! Panels will receive moderator questions in advance, and we will only accept open questions from the audience if all panelists consent.

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!

In this session, we will leverage the JS module (high-performance javascript callback handler) to provide lower level bootstrap endpoints that will act as a highly performant custom API. By only loading what we need, we can reduce server load and speed up delivery by huge margins. This API will be able to serve entity data in JSON and rendered HTML, as well as a few other interesting examples of content. Once we have our speedster created, we will want to see how it performs.

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.

Slides

This session will focus on addressing a growing trend of losing Drupal developers, or at least their interest, because of the cool factor of up and coming competing technologies.

Why Drupal seems un-cool

As technologists, we are always looking out for the “next big thing” partially because of perceived advancements, but often simply because it is different/new/exciting. While each major version release of Drupal has seen extensive advancements, it’s still PHP at its core. Theres a fairly large momentum around the MEAN stack, frameworks like Django or even languages like Go. While not necessarily “new,” in many ways, we find them to be different and exciting because of the additional challenges posed by uncertain big performance and scalability issues - keeping their interests piqued.

Opportunities

We have all made a large investment in Drupal, whether financial or personal time over the years. Continuing to ensure that our platform stays cool in the eyes of our development teams and colleagues can be done in a number of ways from evangelizing all the dev tools to embracing “Headless Drupal” initiatives. I will outline my ideas, many currently in practice at NorthPoint Digital, during the session.

Web accessibility has been important for non-profits, educational institutions & government agencies for ages in the USA thanks to Section 508, but it is becoming increasingly important for competitive businesses as well. Drupal 7's accessibility is still outstanding, but Drupal 8 Core is even better! Learn about some of the big improvements in Core that you'll want to be leveraging in your Drupal 8 themes & modules. Get a better understanding of WAI-ARIA and how this W3C Standard can help you remove barriers for screen-reader users. The Drupal community is striving to make our code (and sites) accessible by default. Learning what of that behavior you can leverage can save you a lot of site development time.

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.

How many times have you received feedback that didn’t make any sense or just wasn’t useful? It’s pretty easy for people to get caught up in their own emotions, losing sight of what others understand and what information might be helpful for them. This is how vague feedback like “Make it pop” or “I just don’t like it” commonly results in frustration and unnecessary iterations, which have the potential to disrupt the timeline or budget of a project.

How do we make sure everyone’s thoughts and contributions are being communicated effectively? Knowing how to give solid feedback internally and encouraging useful feedback externally can solve some of these issues and make the course of a project run more smoothly.

1:30pm - 2:00pm

Websites are never done. Evolving version 1.0 from launch to the next redesign is an unpredictable adventure in problem solving, ingenuity and collaboration wholly distinct from the journey we take when building a site from scratch. Website support is its own discipline. Some sites need minimal security updates, others need constant attention and care to continue functioning, and many sites groan with technical debt from all the things you didn’t get to when you were building them. None of these needs arrive in a steady, predictable stream. This month the site might need 10 hours of work; next month it might need 100. As a developer, how can you make a living with this hurry-up-and-wait workflow? As a website owner, how can you ensure that you’ll have the resources you need when you need them? This session will cover: 1. The importance of minimizing technical debt on existing properties. 2. Seeing support work as an opportunity, instead of an opportunity cost. 3. How we structure our support team in a way that makes good business sense for us and our clients. 4. Case studies showing how incremental improvements can have a disproportionate impact for stakeholders.

2:00pm - 2:30pm

Sometimes ‘node’ is a four letter word. One of those taboo phrases that you’d rather not use in front of your clients. My team loves Drupal; we’re down right evangelists. But our clients just want a website that is easy to use. Making Drupal friendly for clients means checking all of the ‘node’, ‘taxonomy’, blocks’, and other jargon at the door and building interfaces that are intuitive and distraction free. Topics include:

creating personalized dashboards for authors and editors;

defining roles and permissions that follow an organizations workflow;

modifying the node add and edit forms;

adding contextual help to administrative forms and interfaces;

incorporating inline form validation; and

choosing field and widget types that that best fit the content.

This session is for beginning site-builders. It includes a roundup of useful module to customize the Drupal interfaces; tips for configuring Drupal core settings; and examples of using views and some simple hooks for taking control of your theme and content types.

2:30pm - 3:30pm

There's a lot of front-end tools out there you can use with your Drupal themes that will improve your code quality and organisation, development workflow and ability for multiple people to work together on the same project.

This session will show you how you can...

Structure your sass

Use node.js' npm modules

Manage your external packages with bower

Automate your builds with Grunt.js

Save yourself lots of clicking by using LiveReload

Ensure your team is running consistent versions of tools with bundler

Use AngularJS templates in your theme to offload processing to the client-side

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.

In case you've been living in a cave (or maybe a Vogon ship's cabin) the last few years, SEO stands for "Search Engine Optimization." Improving your website's SEO can translate into more visitors, better conversions, more sales, etc. This is why people care about it and why you should, too.

When properly configured, Drupal is a very SEO-friendly web framework. The trick is to know which Drupal SEO modules you need to install and how to optimally configure them.

This session will go over the standard modules used for better search engine optimization in Drupal 6 and 7 including:

A similar talk was given at BADCamp 2009 (Kristen Pol & Jen Lampton), DrupalCon SF Unconference 2010 (Kristen Pol), BADCamp 2010 (Kristen Pol), and BADCamp 2012 (Kristen Pol & Aimee Degnan) as well as more informally at some local Drupal user group meetings.

Aimee has been in the web world since the 90s working as a web architect and project manager dealing a variety of Enterprise content management systems. She has presented at BADCamps, Stanford camps, SANDCamp, and other Drupal camps and user group meetings. Check out her drupal.org page and work history for more info.

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?

Disaster Recovery is a topic that is on everyone's mind, but few know what it means or how it might affect them. With larger and crazier weather on the horizon, current experience of submerged data centers, and a seeming Armageddon of situations making schemes on your data, DR planning is critical to the long term health and prosperity of any Internet-reliant business.

This session will cover DR and Business Continuity as it applies to content providers of all sizes. We will cover planning and testing, in addition to methods for disaster prediction and mitigation. The session will also cover worst practices; things you may or may not be doing that might make things worse (or better) for you when the disaster hits. In this talk I'll be drawing from over 15 years working on High Availability and DR systems, and am looking forward as much to the Q&A as giving the session as the questions asked almost always open up new avenues of discussion and theory when it comes to disaster preparedness.

What this talk will not be is a sales pitch, I will make no attempts to sell you a service or gadget that will be your passe-partout to disaster recovery. I may try to compel your consideration of your needs and wants lists, but the goal is to talk about possible solutions, not sell them. In fact, no products, services, or companies will be mentioned by name during the presentation, except to illustrate categories where appropriate (e.g. AWS for a public cloud provider).

2:30pm - 3:00pm

Design logic dictates how the browser should render content. Designers define these objective rules and developers implement them with CSS. We tell the browser things like "All links need to be underlined" or "All images should be no wider than their parent container." However, an effective design system needs to handle more complex problems than what color the links should be. What about rules like “If this image has a portrait orientation, make it 33% wide and float it to the right?” While CSS becomes more powerful with each browser release, it still can’t do everything. More complex rules need help from the server or client side to help maintaining design integrity. In this session we'll look at breaking down design systems into objective rules that can be implemented programmatically. We'll also explore the limitations of CSS logic and how it can be augmented with PHP and JS.

3:00pm - 3:30pm

Twitter uses Drupal for its editorial content such as blogs or developer documentation.

The team has been building and improving tools to enhance editor's productivity as well as our own productivity. When I started working in the team I was surprised by the lack of a modern template engine which led me to implement Twig in our Drupal 7 environment.

We found a lot of values in migrating to Drupal 8 however as our platform supports more and more sites it would be difficult to migrate them all at once so intead we decided to migrate our platform bit-by-bit before the official release.

This session will demonstrate using concrete examples how we integrated Twig and how we leverage it. I will talk about why modern template engines are useful, why Twig is a very powerful tool and why it should get you excited about Drupal 8.

But it was not all that easy! This session will also highlight the challenges related to inconsistencies in modules, renderable arrays and security requirements to name a few.

Some basic knowledge in theming on Drupal and modern template engines will help you get the most of the presentation. Reading about template inheritance will also be helpful.

My name is Thomas Potaire, I joined Twitter last year and it is my first experience on Drupal. I previously worked with Symfony2 at CBS Interactive. I digged into some of the darkest corners of our Drupal 7 environment (caching, user module, filesystem) and immediately saw how Drupal 8 would benefit us.

3:30pm - 4:00pm

For the first few years of its existence, Alley Interactive was an all-Drupal agency — until a major client asked us to rebuild their site using WordPress, and we took the plunge into enterprise WordPress development. Since then, we’ve gained experience and contacts in both the Drupal and WordPress worlds.

We’ve hired Drupal specialists and WordPress specialists, and we’ve talked to clients who sought our experience specifically because we have a foot in both doors. This has not moved us away from Drupal — in fact, we’ve continued to pursue Drupal projects as actively as ever.

Anyone who’s spent time in either community is aware of the occasional bickering and aspersions cast between the two camps. But in our experience, we discovered more in common than we imagined, and we’ve developed tools and strategies to bring good WordPress ideas to Drupal, and good Drupal ideas to WordPress.

So why always with the fighting? Come hear what we’ve learned and how this bi-modal experience has shaped the way we think about our client projects.

4:00pm - 5:00pm

One of the strengths of Drupal is that it's not just a tool for building a single website. It can be used equally well for managing multiple companion sites together. This capability has existed for many years, but is not always well understood. And in true Drupal fashion, modern Drupal has several different options available for users looking to run a series of Drupal sites together, each with its own trade-offs. This session will explore several leading ways to build and manage a multi-headed Drupal installation, including Domain Access, Organic Groups, and Multi-site. It will also ask the question of whether a multi-headed Drupal is necessary in the first place; often it is not. Attendees should come away better-armed to evaluate how, and if, to roll out Drupal for a multi-part site.

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.

The Drupal core mentoring program has been growing. We have participants in IRC every week, and new contributor sprints have been well attended at every event. People want to give back, and we are attempting to give them a path to doing so, but we still need help.

We always need new mentors and continued support from the community because without these new contributors, core development cannot scale. The good news is, you too can learn to mentor in the Drupal community or your organization.

This session will be intended to give an overview of what it takes to be a good mentor in the Drupal community, and hopefully bring the lessons learned back to your organization. There will be specific focus on the tools and techniques we use to mentor new contributors, and strategies for helping people succeed.

You will come away from this session with an understanding of the Drupal Core Mentoring program, some tools you can use in your community or organization, and knowledge about where to find more information.

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!

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.

4:30pm - 5:00pm

Lock down which project is using which Ruby gems, on which versions, with Bundler! Gem versions can be a pain to manage, especially if you or your team members work on multiple projects simultaneously, or if you work with contractors, temps, etc. Case in point: projects stall, people leave, and hand-offs often don’t include robust documentation.

Using Bundler is a great practice if you aren’t going to be working on a project forever and someone else will have to pick up where you left off, if you are working on one legacy project and one bleeding edge project, or if you frequently come back to projects after not working on them for some amount of time. Additionally, it can be difficult to get the right gems (dependencies on specific versions) if you have multiple versions on your system. Setting up, managing, and updating your ruby gem environment is a tedious task. Bundler can help!

5:00pm - 6:00pm

In the face of bewildering advancements in the front end, it's useful to take a step back and take stock of where the fundamentals are headed: namely HTML and CSS. These two lowly languages have been largely left by the wayside as we front-enders scream ahead with abstractions and frameworks. But where are HTML and CSS headed exactly? This session examines progress working groups have made to the existing standards, techniques that are already or will soon be available for developers, and some of the proposals being floated around the standards.

We'll devote our attention to the following questions: How far have HTML and CSS come? What upcoming techniques or proposed additions are most relevant to us as Drupalists? What does the future of HTML and CSS look like in terms of cross-browser compatibility, programmatic approaches, and more extensive possibilities? What are Web Components and the Shadow DOM? How can we prepare for the approaching future of HTML and CSS?

Just some of what we will delve into:

A brief retrospective: Where are we now?

The current rendering engine landscape

Vendor prefixes: Dead but not extinct

New selectors, combinators, and pseudo-classes

Flexbox, Grid, and other layout

CSS backgrounds, borders, and gradients

CSS variables and extensions

Web Components and the Shadow DOM

Custom elements, HTML imports, and CSS scope

General implications for Drupal

... and much more

This session is geared toward front-end developers, themers, and designers interested in a robust crash course in where HTML and CSS are headed in the short and long term. This session also assumes an advanced understanding of modern HTML and CSS. Though some of these techniques are still unavailable for general use, this session will give you the tools to engage in the discussion and to plan for the future of markup and style.

About me

Preston So has designed websites since 2001 and discovered Drupal in 2007. He is a Software Engineer at Time Inc. and also co-founded the Southern Colorado User Group. Since 2008, Preston has spoken at conferences and camps across the U.S. and on two continents (most recently DrupalCon Amsterdam 2014 and DrupalCon Portland 2013) on topics such as design, theming, usability, responsive design, and cutting-edge CSS.

Note: This session is an updated version of the DrupalCon Amsterdam session The Future of HTML and CSS. It is also a sequel to Frontiers of CSS (BADCamp 2012, DrupalCamp NJ 2013, DrupalCamp CT 2012).

Drupal has features falling out of its butt. And where a feature doesn't exist, Drupal has highly generative systems that usually allow the clicking together of new features. We already have tons of stuff to make things "easy." Problem is, 'easy' doesn't scale.

Drupal isn't losing market share because its feature checklist isn't long enough. It's losing market share because its essential design makes it difficult to scale into complexity. Complexity slows down innovation, release cycles, and introduces a subtle upper bound on the interesting-ness of feasibly solveable problems.

So, if you really want to help out Drupal, don't think about features. Don't even think about "making it easy." Think about reducing complexity.

This is an updated reprise of my talk from Drupalcon Austin, incorporating some elements from my Keeping it Simple essay, and accounting for some of the interesting discussions in the community that have been burgeoning since then. The talk is strongly rooted in Rich Hickey's Simple Made Easy, which is profoundly worth watching.

Recent high-profile breaches have shown that data security is more important than ever. As clients are becoming aware of the devastating consequences of a data breach and compliance requirements are becoming increasingly stringent on what is considered sensitive information, it is up to Drupal developers to ensure that the web sites and applications that they are building are using security best practices and have proper controls in place. We will cover best practices in securing your Drupal site from attacks and intrusion as well as how best to handle and encrypt sensitive data.

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)

This panel will discuss the latest developments with large-scale Drupal Distributions. We'll discuss the challenges of supporting and updating large distributions, the pros/cons of creating and using distributions, if/how distributions are migrated to Drupal 8.

5:00pm - 5:30pm

Design is at the core of every project Aten takes on. We believe good design starts with a good content strategy. Join Aten’s Joel Steidl, Lead Architect, and Christine Coughlan, Information Architect, as they share practical tips for breaking down and organizing content for projects of any size.

Starting with a well-thoughtout architecture leads to flexibility in design. Creating custom content types assembled from distinct fields allows content to adapt appropriately to different contexts. Joel and Chris will explain how breaking content into smaller pieces can enhance your design and create content that adapts to different views and devices. They will share case studies to reinforce the theory and practice behind adaptive content and best practices for implementing in Drupal and other platforms.

What we hope you'll walk away with:

Know the visual benefits of structured content over content created using a WYSIWYG editor only.

Learn what adaptive content means.

Add design consistency between similar content on your site.

How front-end developers can use view-modes for adaptive content.

How to improve the publishing experience using straight forward content entry forms.

This session was also presented at Design4Drupal 2014 in Boston.

5:30pm - 6:00pm

Responsive Web Design (RWD) is increasingly vital in the contemporary web landscape, where your content can be displayed on a phone, a laptop, an 84-inch 4k monitor, a refrigerator, or even a watch. In this session you will learn how to leverage the Picture module (and its dependency, the Breakpoints module) to achieve responsive image loading in Drupal 7.

The Picture Module

There is no RWD solution for images in Drupal 7 core. Luckily, a responsive image handling module called Picture will be included in Drupal 8 core, and has already been backported to Drupal 7. Picture uses the new HTML5 picture element.

This session will cover:

Installation and configuration of the Picture, Media, Chaos Tools Suite, and Breakpoint modules

Creating breakpoints and breakpoint groups

Configuring picture mappings

Setting up file type display settings

Applying these options to an example content type

Basic introduction to the picture element and media queries

Image loading is particularly important for RWD; loading an image size inappropriate to screen resolution is problematic whether you're stretching a 100x100 thumbnail over a massive screen, or sending a ten megapixel background to a QVGA phone. In the former case you're making a pixelated mess, and in the latter case you're eating up both your own bandwidth and your user's data plan on a resolution they can't use - nobody wins.

Benefits for Your Site

There are many reasons to responsively load images on your site. A few highlights are:

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.

As the sites we build get increasingly complicated, the wireframing phase is increasingly important. Solving high-level usability challenges early in the process is saves time and money for you and your clients! In this talk, I'll share the techniques and tools we use at Chapter Three to quickly produce high-quality wireframes and maintain your UX sanity.

WE'LL ALSO DISCUSS:
• Why paper is the most important tool
• "New" exciting tools for producing wireframes (like Sketch)!
• How wireframing can be a vacation from designing
• Using wireframes to test the usability of your website
• Creating wireframes for responsive websites
• How you can learn to stop worrying and love Helvetica (again)

NOTE: This talk has evolved significantly since it was presented at BADcamp 2013 and at Drupalcon Austin 2014. Lots of new stuff to share and plenty of good foundational information for anyone who hasn't seen it already!

Menus, breadcrumbs, and path aliases have been core features since anyone can remember. Yet the core functionality is still pretty bad.

I'm a believer that:

- Beautifully structured URLs are an important part of your site's design
- You should almost always include breadcrumbs and they should always be correct
- You can display one breadcrumb and one path, and they should always be in harmony (two formats of the same structure)
- A site's navigation should all fit into a single tree
- The menu position, breadcrumb, and URL should all be in harmony within that one tree
- A URL should mimic a real directory structure, and be navigable
- If you have a page with more than one path or menu position, one path and menu position should be canonical

For many years I've fought with core's handling of paths, menus and breadcrumbs as it does not seem to support my beliefs. I've tried many, many different approaches. Finally I'm happy with my set of configuration, modules, core patches and philosophy, and would like to spread the technique as well as the passion for perfection in this critical aspect of your projects.

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.

Managing content on Drupal can be as simple as making changes straight on production, however that is risky and can be very dangerous. If something goes wrong, you're to blame. Also, if you do not set up your content deployment strategy correctly for your company's processes, it can be inefficient and clunky, and as a result you and Drupal are to blame. Have no fear, this has all been solved already with a series of best practices and well-seasoned modules! In this session, I will teach how to reduce the risk and inefficiencies in your current content deployment process and turn your Drupal site into that well-oiled content deployment machine! I will talk about the following content deployment strategies, how to setup them up, and when you should use them:

Modifying content on production

Creating a review process

Staging content before migration to production

These strategies include use of the following modules:

Workbench & Workbench Moderation

Workflow

Revisioning

Deploy

About the Presenter

James McBryan runs TechScouts, an enterprise Drupal freelance agency located in Oakland, CA that specializes in Drupal architecture and custom backend development. Having developed on Drupal for the past 5 years, and previously run a larger agency of 8 individuals, James' Drupal knowledge spans from backend development to product management to building businesses. James was also previously president of Hubmasters, a Toastmaster's club for entrepreneurs, and he currently runs 2 startups, OurVolts ( built in Drupal, iOS, and Android ) and GroupCarpool ( built in Ruby on Rails ).

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.

10:30am - 11:00am

Boring part: Docker is a container system that provides benefits similar to virtualization with only a fraction of the overhead. Scintillating part: Docker can host between four to six times the number of service instances than systems such as Xen or VMWare on a given piece of hardware. But thats not all! Docker also makes it simple(r) to create transportable instances, so you can spin up development servers on your laptop.

11:00am - 12:00pm

You have 9 months to make 188 university websites responsive. You have to use as much of the existing design as possible (design changes require approval) and you cannot make any changes that impact your client web editors. You should also make the sites more accessible. Go.

PS: the CMS you're using isn't Drupal.

Responsive design is complicated enough when you're starting from scratch to create a new design. What about retrofitting an existing design to make it responsive? How do take a website design that predates Apple's iPad and update it to adapt to as many devices as possible? How do you do all of this without adversely affecting your web editors, site admins or site visitors?

In this session, I'll present the challenges we faced while converting a large university web presence to a responsive design. I'll talk about the design trade-offs our team faced and how we worked through them. I'll explore the process and philosophy we used to guide us through difficult decisions on the project. On the technical side, I'll talk about how we made decisions about frameworks and dev tools, and provide an overview of the technology stack we used to develop our new web templates (SCSS all the things!). Most importantly, I'll talk about the lessons our team learned (including the hard ones) and offer my advice to any team facing a "responsive retrofit."

Remember when I said the CMS wasn't Drupal? I wasn't kidding. But fear not, I will still talk about Drupal.

Content strategy is the process by which content is analyzed, sorted, constructed, and placed. Users come to a site for its content first and foremost, so it is the most important part of a site. Before any discussion of design or development, an understanding of a product owner's content is imperative in order to produce not only an effective website, but lay an effective foundation for any and all future endeavors, from apps to ads to printed material. The entirety of a finished product is determined by this initial step, from what content actually is put onto pages to what components get built to what the final site looks like.

This talk will provide a high-level overview of the six items that go into creating a project's content strategy, including:

Planning BADCamp is more than just a hobby, or a pastime, or even a community effort -- it's a perennial obsession, a kind of shared collective insanity that drives us to organize one of the largest Drupal events in the world, year after year.

For us, it's a labor of love and the embodiment of our ideals: diversity, equality, freedom and a belief that technology can empower and bring about positive change to the world.

Come join a panel of some of the core organizers of BADCamp where we'll talk about the method and madness of organizing the event year after year, and share lessons learned that can help you with your local tech community, meetup or event.

We've all heard about the Golden modules like Views, Features, Chaos Tools and Media that are pretty essential to building an excellent Drupal site but there are many, many smart modules that can make our sites more functional and easier to work with.

We're going to share a few we like to call Gems. We'll introduce you to 10 or so that are quick to install and configure and can have a big impact on your site building. Some will appeal to specific use cases while others can be included in every build. We'll run through configuration and show you some examples of:

Meta Tags

External Links

JS Injector

Modernizr

SEO Checklist

HTML5 Tools

Theme Key

Block Class

Webform Classes

Visit our live site to see the material we covered in our session here.

11:30am - 12:00pm

Nightmare clients. Everyone has them at one time or another. They ask for absurd combinations of features and no budget to support them. They ask for work to be done on ridiculously tight deadlines.

We rage about these clients. If only they knew better. If only they would listen to us. If only they weren't so...so stupid.

The reality is, these clients have a reality of their own. They are dealing with the pressures and requirements of their business, many of which are only loosely connected our work. Some of the decisions they make have drivers that may not be immediately apparent to us. If we start trying to see how their business looks from their perspective, they may start to seem less crazy to us.

Engaging our clients with empathy allows us to go beyond just "doing work" for them. It sets up a relationship with the client that allows us to start the design and development process from the right assumptions. We become a partner to them in their business, see what their goals actually are, and are able to give them the guidance and advice that they truly need.

In this short talk, we will look at how focusing on empathy with clients can improve our working relationship with them. Empathy can build trust and allow us to make the best decisions from a well-informed perspective. It might also save our sanity.

1:30pm - 2:30pm

"Everyone has been talking about Sass, but I have no idea what it is or how to get started." "I’m comfortable with writing CSS and the command line is scary. Why should I learn YET ANOTHER new thing?" These are common feelings for developers who are either considering or getting started with Sass. Sass is a powerful CSS extension language for front-end developers, and it’s used in an increasing number of Drupal starter themes, including Zen and Omega. Developers love Sass because you can: -Define components once and reuse them throughout your project, rather than repeating the same CSS over and over (change your font-size or font-family in one line and it will update everywhere!) -Nest your CSS for more logical, maintainable stylesheets (use wisely!) -Perform advanced processing before your CSS is compiled, such as calculating color functions or creating image sprites Although it’s powerful, Sass can be intimidating for beginners. In this session, we’ll go over what you need to know to get started kicking boring, bloated CSS ass with Sass. We’ll also cover: -Basic Sass terminology -- mixins, variables, nesting, amp (&) and more -How to compile Sass into CSS that your browser can read -Tools and handy mixins that will make your front end development easier -Integrating Sass into your workflow and overcoming challenges

Drupal development is getting more sophisticated. You may use a Drush make file to build a Drupal site instead of checking core code into your repo. You may use Behat to run automated behavioral tests against your site. You may use Compass to compile your Sass files into CSS.

As we add tools to the development process, we need something to make them work together. Enter Grunt!

Grunt is a well-supported and flexible JavaScript-based task runner. In the Node.js and front-end worlds, Grunt is widely adopted for automating build and processing tasks (think, linting and minifying JavaScript).

I'll demonstrate the free and open-source Grunt Drupal Tasks project, which provides a set of common tasks related to building and testing Drupal sites. By the end of the session, you should know how to start a new Drupal project using Grunt Drupal Tasks for coordinating build and testing tasks.

Web technologies are evolving at amazing speeds. Drupal is growing in usage, community and code base, and with this growth Drupal is evolving too. Just like in biology, with rapidly changing environments, there are cycles of new life and extinction, and with the massive changes in Drupal 8 many are making predictions about how Drupal will fare in the new cycle.

There is great optimism about the changes and improvements in Drupal 8, but there are also many that are waving warning signs about the more dire paths that Drupal could be stepping upon.

In this session I will bring as many of these perspectives together to crystalize the conversation around Drupal sustainability by looking at Drupal’s current state and by connecting the dots that allow us to arrive at the place where Drupal should be.

Will we be able to connect the dots, or should we be looking in different directions? This is an important conversation that we should continuously have without the blinders of our love for Drupal. Lets get started.

P.S.

I am very happy that Dries himself brought this converstion to the front-page of things we should care about in the Drupal community by focusing his DrupalCon Amsterdam Keynote around the analysis of sustainability and possible solutions to achieve it. I look forward to the continuation of this conversation, to the different angles from which we can look at the issue, and to the many other things we can do to reach the necessary balance.

HighWire Press is an online publisher of scholarly and academic journals and books. The center of the HighWire publishing platform is a central content database containing more than 100 million records representing the articles, chapters, figures, and tables from >1800 Journals and >10000 Books. Surrounding this central content repository is a suite of services which comprise a service-oriented architecture. On top of all of these services and content is Drupal.

Some of our biggest challenges are how to efficiently build over 2000 sites that give the feel of a custom site while maintaining a platform approach so we don't incur the work to support custom sites. We need to be able to configure hundreds of sites at a time in a flexible but consistent manner and roll out platform updates to all sites on a monthly basis with a minimum of staff.

In this case study we will present how HighWire has used Drupal as a front-end framework for building sites to display published material and to leverage an XML-based service-oriented architecture. We present strategies for managing content in sites which contain >500K nodes and site-building approaches for sites that contain up to 2500 Books in a single site. We will also discuss performance optimizations for sites which serve several million unique users each day.

Finally we'll present approaches for automating site management, configuration and building. We'll also present a new approach for using CTools content types and Features to consolidate configuration options from a plethora of admin screens into a unified configuration tool to allow for efficient site building by relatively non-technical staff.

Slides of this talk are available at http://home.highwire.org/sites/default/files/additional_assets/ppt/BADCamp2014-CaseStudy.pptx

What are the problems that science is good at solving? What are the problems that startups are good at solving? What can one learn from the other? Welcome to the new world of entrepreneurship! Software has made it possible for enterprises to capture and use information in powerful new ways. The age where decisions are made by fiat are long-gone. Welcome to the age of information-based decision-making. Whether it's building a business or building features, we talk about applying the scientific method to building websites and using Drupal. We'll discuss setting up simple data capture and data analysis flows, as well as best practices for running tests and how to use science to make better software.

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:30 pm - 4:30pm

Over a thousand people participated in the issues around improving multilingual features and APIs in Drupal 8 for the past three years. There are around a thousand issues, most of which are resolved in this initiative as of this submission making Drupal 8 a truly outstanding release for everybody looking to create even single language non-English sites but especially those making multilingual sites. Although there will surely be contributed modules useful to round out multilingual sites in Drupal 8, there is support for way more than there was in Drupal 7 core and even if you add in all available contributed modules - and with less code and more unified approaches.

This 2 hour lab aims to provide a hands-on way showing you around all the great improvements and gives tips as to how to best utilize the new solutions. We will also talk about where contributed modules will still be needed.

The ideal attendee at this session has some experience in Drupal 6 or 7 foreign language and/or multilingual site building, however those who have no experience in foreign/multilingual site building will also get a lot out of it.

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.

Speed Up your site!

But don’t take my word for it.

We’ll do a series of experiments, comparing an uncached speed test to start, and then get faster and faster via optimization. Watch as we employ various methods to speed up your site, with benchmarks to prove it!

“With render_cache it will be possible to really just rebuild the parts of the site that have changed, which will make even authenticated user pages very fast” and why you can “never worry again about content expiration.”

We’ll conduct a series of experiments in caching and optimization using Varnish, Facebook Big Pipe, render_cache, and more.

We’ll also take a look at considerations in striking a balance between speed and performance and fresh, dynamic content, looking at a few tips and tricks to take total control of your caching.

You’ll walk away from this session ready to apply several techniques to make your sites faster and resources to get you on your way to even further optimization.

Get inspired and do it yourself!

I am a user experience researcher and Drupal content strategist. Every time I present a session on UX for Drupal, half a dozen folks come up to me afterwards and say, "so, this is all really awesome stuff and I am personally fully sold on UX, but how do I get buy-in from real clients / stakeholders / my boss?"

This session is for all of you who want to include UX in your projects but need to get someone to pay for it... How to sell user experience design for Drupal projects:

✓ Understand your audience
✓ Have a UX sales plan
✓ How to show how UX impacts the bottom line
✓ How to create a UX sales kit
✓ Demonstrating how UX solves Drupal problems
✓ Euphemisms for UX work
✓ Finding UX champions

DoSomething.org completely rebuilt its core software product starting by scuttling the old, bloated, overly-complex codebase to achieve the following

Reduced size and complexity of the codebase

A clean, self-building platform

Maintainable code quality at scale

This session will cover how the new DoSomething.org was conceived and built to be a scalable, open platform leveraging modern development and deployment practices like installation profiles, build scripts, Jenkins, Capistrano and Hubot.

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:00pm - 3:30pm

Everyone knows that the unofficial motto of Drupal is, "There's a module for that!" But everyone also knows that the fastest way to having the slowest site is to install every module under the sun. Still, when the client ranks a piece of functionality on their "must-have" list, and the only way to accomplish it involves installing a complicated module or writing your own, what other option do you have, even if it means you're site is slow as molasses? Enter Varnish, the reverse proxy wunderkind. Varnish lives near the top of the Web caching stack, intercepting every request and transforming it in arbitrary ways. At the end of this transformation pipeline, the request can be fulfilled by any of a configurable set of backends, by a cached copy of a previous backend response to a similar query, or even by a synthetic response created within Varnish itself! As a practical matter, this translates to the ability to efficiently load-balance without a dedicated load-balancer, run staging and development side by side, filter DOS attacks, and speed up your site to an extent unmatched by anything you've worked with before—even static HTML pages served by nginx aren't as fast as a Drupal home page served by Varnish. We'll start by examining what a HTTP request looks like under the hood, with a quick primer on relevant underpinnings using the OSI Model. Next, we'll consider how a request flows through Varnish from connection to completion, and the various pieces of a VCL (Varnish Control Language) program and what they do. Then, we'll dive deep into some real-world examples and look at both simple and not-so-simple solutions. Though this is intended as a beginner-level session, if there's interest or extra time, we'll finish by touching on just how powerful VCL can truly get, by considering the possibilities inherent in synthetic response creation, ESI, and C extensions.

3:30pm - 4:30pm

The Twig templating engine is in Drupal 8 and has generated a lot of excitement. Many passionate contributors have stepped up during the Drupal 8 development cycle to not only convert Drupal’s markup to Twig but also clean up and simplify the theme system as a whole. But what does all this mean to you?

This session covers the state of Drupal 8's theme system. We'll talk about what's different from Drupal 7 but also walk through some of the internals of different aspects of the theme system and how they might affect your day-to-day work with Drupal. Many parts of the session are applicable to Drupal 7's theme system as well so you can use some of the knowledge right away.

We’re going to talk a lot about code and APIs and look at plenty of PHP, so an understanding of PHP basics will be helpful.

Topics include:

A high-level overview of the changes to the theme system in Drupal 8.

Some of the goodies that are possible now that we’re using Twig as our templating engine.

Using theme hook suggestions to cut down on custom code and have themers thanking you.

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.

Frontend development is becoming more critical as web development matures. As we grow our need for backend-like workflow tools increase. During our day-to-day site development in Drupal we all have to do repetitive tasks. Let's take the pain out of the process and focus on our actual work by learning how to utilize modern frontend automation tools.

In this talk, I plan on discussing various tools that help frontend developers stay consistent as they develop their drupal themes. I will focus primarily on gruntjs and bower, but will also briefly discuss Gulp.js, PhantomJS, PageSpeed, and CasperJS. I’ll show some small (pre-recorded) demos of the tools in action, and discuss how much you and your site will benefit from the use of these tools in your day-to-day work lives.

4:00pm - 4:30pm

To DIY or not to DIY? This session will cover when and why you might need some outside help--and some common pitfalls to avoid when trying to go it alone. We'll also cover things you can't outsource, no matter how much you'd like to--because you can try to do too little, which has as many problems as trying to do too much. We'll discuss some different ways you might work with a vendor, how to identify your needs in a way that will lead to a good match, how to manage the selection process, and how to keep your project and your budget under control once you've got outside help.

[PRESENTER'S NOTE: Crikey, the last session on the last day! Feel free to bring your beer. We'll tailor the session to whichever die-hards show up.]