"Life" room

Overview

Relational databases store, index, and retrieve data using using predictable patterns. Indexing data well -- but not excessively -- requires understanding indexing overhead and usage by query execution planners.

But, even the perfect indexing plan layered on top of existing tables cannot satisfy all needs: relational databases have significant limitations for indexing data. Particularly, they cannot index data across multiple tables. While Oracle and Microsoft SQL Server provide some in-built tools (materialized views and indexed views) for alleviating this limitation, users of open-source databases like MySQL and PostgreSQL must consolidate and preprocess data to scale popular services.

The Denormalization API streamlines the process of consolidating node data into tables structured for radical scalability.

Agenda

* How is Drupal data stored?
* Overview of indexing tables
* Index data structures
* Query execution plans and indexes
* What is denormalization, and why is it necessary?
* Typical hurdles for implementing denormalization
* Using the Denormalization API

Goals

Attendees should leave with an understanding of the benefits and caveats of indexing and denormalizing data. And, if they choose to denormalize, how the Denormalization API can streamline the work.

Resources

Attendees should be familiar with Drupal's node system, SQL, and basic database administration.

Overview

The Drupal community is jumping in the Semantic Web bandwagon. Semantic Web Applications built with Drupal are starting to emerge from the different use cases of the community.

The Neologism project is one of the applications that benefits from the power of Drupal, but also constitutes a building block for the Semantic Web.

Neologism is a lightweight web-based vocabulary editor and publishing tool built with Drupal. It makes vocabulary authoring easy and fun. Just create a vocabulary, add classes and properties to it, and your vocabulary is instantly published and available online! Several formats are supported via content negotiation: HTML, RDF/XML and N3. All the term URIs are dereferenceable and point to their human readable description.

Some other Semantic Web projects could also be presented in this BoF.

Agenda

* What is the Semantic Web
* Neologism use case: how Drupal helped us
* Why a Vocabulary editor?
* Other Semantic Web projects built with Drupal
* The future of the Semantic Web and Drupal

SESSION OVERVIEW

This lecture-style session will present and discuss various approaches to improve front end performance. While server side performance has an impact on the speed websites are delivered, the vast par of loading time is spent on retrieving CSS, JavaScript and image files. For a truly zippy website, it is therefore vital to drastically lower the amount of time spent here. In his book “High performance websites”, Steve Souders discusses various ways to accomplish this. This session is based on that book but contains additional Drupal-related information and strategies.

AGENDA

* Anatomy of a web page
* Measuring the non-obvious and identifying bottlenecks
* The Hypertext transfer protocol
* Reducing HTTP requests
* Configuring Apache
* Additional optimizations
* Content delivery networks
* Related Drupal modules

GOALS

You should get a feeling for what “front end performance” actually means and where the main problems are located. You will also learn how to tackle these issues in a structured manner, measure the effects and get to know the basics of the foundation technology of the web, the Hypertext transfer protocol.

RESOURCES

You should be familiar with how a website is structured and know basic Apache configuration. Being familiar with HTTP is a bonus.

Overview

Analysts estimate that 75% of attacks against web servers enter at the application, not the network level. And as many as 15% of these attacks are due to poor coding practices. With the help of well known security firms, We'll discuss ways to secure your Drupal application.

Agenda

* See For Yourself - demonstrations of application attacks
* Case Study: Secrets to Securing a Social Network
* Key Habits of Secure Drupal Coding
* Vulnerability Detection to Remediation
* Security Resources for Drupal Applications
* Discussions

Goals

You will learn best practices you can employ right now to build secure Drupal Application code that meets security compliance standards and maintain customer confidence.

Overview

I've been asked to give a talk on the specified topic by the track co-chair. Since I am now running large scale Drupal installs for over two years (mainly drupal.org) I have learned a few tips about making your Drupal code run fast and not give your server a hard time which I want to share.

Agenda

* Drupal caching in core
+ Drupal 5
+ Drupal 6
+ Drupal 7
* Mistakes to avoid when programming Drupal
* Tips and tricks.
* Different cache backends.
* Other stuff (basic server config)

Goals

I'd like attendees to gather an understanding for why caching is important and the pitfalls that may occur.

Resources

General familiarity with Drupal is going to be helpful.

Overview

In this second session on jQuery we plan to focus on Drupal-specific usage and also on more advanced topics such as effective debugging of js code and adding AJAX functionality.

Agenda

* How Drupal and jQuery relate to each other
* The Drupal js object
* AJAXifying Drupal with jQuery
* AHAH and Drag&Drop

Goals

By the end of this session, attendees will understand the fundamentals of how jQuery and Drupal work together; they will have learned some best practices regarding the use of jQuery in Drupal and be able to add AJAX, AHAH and Drag&Drop functionality to their modules (the latter two for Drupal 6 only!)

Resources

Prior knowledge of jQuery basics or attendance at the first session recommended. Attendees should also be familiar with basic Drupal module development.

Overview

Drupal module development is a bit like playing Zork. Anyone can play the game, walk around a while, score some points, get eaten by a grue, and try again. Even the most stalwart adventurer will need some help if he is to seriously improve his game. Otherwise, he'll get fed up with Zork and return to playing Duck Hunt.

So it is with module development. You've setup a Drupal site. You've used some contributed modules. You've tweaked some to your liking and even written a couple from scratch... but you need to know how to improve your game before you get frustrated or waste all your time making the same mistakes. Yes... there are plenty of mistakes to be made, and we've made quite a few of them ourselves.

Expect more classic gaming references in this session, but more importantly expect to learn about the things we've done wrong and the things we're starting to do right in our Drupal module development (primarily Ubercart).

This session will be geared toward beginning and intermediate Drupal developers looking to learn more about the module development process and "best practices" that go beyond (but certainly include!) simple adherence to coding and security standards. We will cover the tools we use, the module structures we like to stick by, and how we make the most of our first pass at a module. More importantly, we'll look at code that works with some of the harder to understand parts of the Drupal API, and we'll look at writing modules that integrate not just with Drupal but with other contributed modules like Ubercart and Views.

Sounds like a lot, eh? We think so, too. However, we'll be presenting the information in the following format to try and disseminate as much knowledge as possible:

A Hands-On Guide to Module Development will be an informal lecture session where we say our opening words and move into a time of hands-on learning. Those with laptops can follow along with code examples as we work through the development of a module that demonstrates the topics mentioned above. We'll be accepting quick questions as we go along and use any time at the end to take more questions and hopefully provide some helpful answers.

As always, if we can't get to you in the session, feel free to stop us in the halls or find us around Drupaltown and get your learn on.

We're open to collaborators interested in the topic and the format. Interested developers should contact Ryan or Lyle (Island Usurper). If you just want to contribute your module development best practices, we'd love to have a nice happy list for folks to use as a reference coming out of this session.

Agenda

* Introductory words
* Getting ready to code - think first
* Where to start with a blank file
* Writing those first hooks and callbacks
* Writing smart functions
* Documenting as you go!
* Grokking some more Drupal hooks:
   - hook_form_alter()
   - ... (to be determined)
* Hooking into contributed modules:
   - Ubercart
   - Views
   - ... (to be determined)
* What to do when you're "done" ; )

Goals

Attendees should leave with a greater sense of what it takes to develop Drupal modules successfully. There's no way to pass on a comprehensive understanding of what we know or get to cover, and that is a subset of all there is to know about module development. However, every little bit helps, so we'll try to pass on as many little bits as we can!

We want to help move as many beginner developers as possible toward the intermediate level and entice those intermediate developers to become the experts we know they can be.

Resources

* Drupal 6
* http://api.drupal.org
* http://drupal.org/project/ubercart
* http://drupal.org/project/views
* http://www.infocom-if.org/downloads/downloads.html

We will include a downloadable zip of code examples for session attendees to use to follow along as we write the module, discuss the code, and discuss how we got there.

Overview

This session, run by the authors of Organic Groups and Domain Access, will give an introduction to the workings of Drupal's node access system.

Agenda

* What is Node Access?
* How does it work?
* What modules provide node access?
* Exploring the current API
** Enabling node access
** Defining access realms
** Defining access grants
** hook_node_access_records()
** hook_node_grants()
** db_rewrite_sql()
** Changes from D5 to D6
* Common problems and issues
* Best practices for using node access

Goals

New users should come away with an understanding of the features and limitations of the node access system. Programmers should come away with the ability to write a node access module, using the existing API. Everyone should come away thinking about how to make the system better.

Resources

See the node acccess example module for background.

Overview

The Code Review module (aka coder) is a useful tool for module and theme developers. It allows developers to ensure that their code meets the Drupal coding standards and also assists them in upgrading to newer versions of Drupal. If you write or maintain code (mostly modules, but themes too), you should be using this module.

Agenda
* Discussion of Common Style Problems that Coder identifies for you.
* We’ll run Coder on a module.
* We’ll show how to setup Coder to run it on ALL your modules.
* Overview of using Coder for upgrading modules to Drupal 6, including some examples.
* How to submit coder rules and help make Coder better.
* Floor Discussion on the direction Coder should take.
* Q&A session.

Goals
By the end of this session, attendees will have a good grounding in what the Coder module does and how they can use it to improve their modules / themes.

Resources
Attendees should already be familiar with basic Drupal module development.
* Coder project page - http://drupal.org/project/coder
* Drupal Coding Standards - http://drupal.org/node/318
* Converting 5.x modules to 6.x - http://drupal.org/node/114774
* Writing Coder Rules - http://drupal.org/node/144172

Overview

Tuning the Drupal stack continues to be an exciting combination of science and art. New options for cloud computing and infrastructure services like content distribution networks allow performance load to be distributed. The art of offering your users the right combination of features without creating a performance impact is a design challenge.

Agenda

* Performance tuning the Drupal stack
* Tuning images, CSS, Javascript for front end optimization
* Outsourcing your performance load
* Performance load testing
* Scalable architectures for peak loads
* Performance improvements in Drupal 6 and Drupal 7

Goals

The goal of this session is to learn best practices from a panel Drupal performance experts. We will review the latest tools, techniques, and architectures for ensuring your Drupal site stays fast and can scale under a variety of of loads.

Resources

http://groups.drupal.org/high-performance
http://groups.drupal.org/node/12823