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.
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.
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.
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!
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.
GitHub repo: https://github.com/phase2/grunt-drupal-tasks
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.
1:30pm - 2:00pm
- Plan B ?
- Types of SSO
- Why Identity Management
- Commandments for IDM
- Devil is in the details
- Methodology and Monitoring
- Deployment Plan
- SSO Drupal Modules and Techniques
- References and Information
- Contact Info
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.
Want to be involved in this project? See http://hojtsy.hu/multilingual-drupal8 for an article series on the details on what we accomplished. http://www.drupal8multilingual.org/ is our initiative home and we have meetings every Wednesday to discuss and move current efforts forward (see times on the front page).
Preparing for this lab: Coming soon. We are working on providing cloud based environments to the class to speed the ramp up process for the lab.
2:30pm - 3:30pm
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!
Inspired in part by the recent session at DrupalCon Amsterdam, Render Caching in Drupal 7 and 8 (https://amsterdam2014.drupal.org/session/render-caching-drupal-7-and-8) that revealed how:
“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!
And we'll have fun!
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: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.
- 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.
- Phases of the theme system and where you can step in to alter things.
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.
Saturday, November 8 2014
10:00am - 11:00am
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 :)
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
Have you ever participated in a Discovery Session? Yes? No? Doesn't matter - this session is for you! This session will go through the basics of a productive discovery session.
From this session, attendees will walk away with a better understanding of:
- Discovery Purpose
- An understanding of why Discovery is important for Drupal Projects
- Discovery Definition
- Intended audience and balance for Discovery
- Sample Discovery Agenda
- Discovery Methodology
- Discovery Tactics & Logistics
- Next steps following a successful Discovery Session
(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.
11:00am - 12:00pm
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.
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
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.
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.
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 )
What this session will cover:
The difference between concurrent users and user sessions
Learn how to identify and build individual usage scenarios
The metrics that will help in developing realistic workload characterizations
Learn how to identify and model special considerations (APIs, Forms, Personalization)
Learn how to construct realistic workload models
Writing a Performance Test Plan
When a heavy load is applied to the site, where do bottlenecks emerge?
What page response times can anonymous users expect?
What page response times can authenticated users expect?
How well does the Drupal caching layer protect APIs from heavy traffic?
Overall system availability and response time are the key metrics that will result from the tests performed.
Types of Tests
Consistent Load Test Scenarios
Stress Test Scenarios
· Average Response time (in seconds)
· Average hits per second
· Total transactions per second (passed and failed)
· Total errors
· Slow queries identified
· CPU, Memory utilization
· Load Balancer, Varnish, Database analysis
· Possible bottlenecks identified
Test Environments and tools
Timeline for Performance Testing
Acceptable page response times
Current Editorial statistics
Reporting and Remediation
Optimizing the front-end
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.
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)
Last year, I showed you how to be boss with rules!
This year I'm gonna rock your socks with a dazzling presentaion about:
- A Drupal 8 rules demo
- Impacts for users of Drupal Commerce
- How you can get involved and be a rulemaker!
- Gary Coleman and David Hasselhoff