EventsSchedule

Workshop participants will sign in and receive their passes and orientation materials.

During this session, workshop participants will be set up with a basic working development environment.

We'll download and install CakePHP, and take a walk through the directory structure, with a brief explanation of MVC, and how the different parts of the framework interact to solve common problems when designing web applications.

We'll also take a look at an overview of the application to be built during the tutorial, and a break-down of how we'll be designing it.

We'll begin by determining the data we need to create our application, and how to relate that data.

We'll then build out the database schema for our application, and use it to generate model classes, where we'll learn about modeling data relationships, and basic data validation.

Finally, we'll see how Cake's scaffolding can help us quickly visualize our data, and input some dummy records for further testing.

Now that the application has its basic structure and some example data, we can make it more functional and user-friendly.

We'll start by building our first controller actions, complete with custom views and interactivity, including pagination.

We'll build and handle custom form input, and learn how to implement more human- and SEO-friendly URLs.

After learning the basics of modeling data, we'll examine in depth the tools that Cake gives you for interacting with it: behaviors and DataSources. In this session we'll learn about behaviors, how to leverage Cake's core behaviors and how to build your own. We'll also cover DataSources, and how you can use them to leverage Cake's model infrastructure with custom types of data, like web services.

We'll also look at some advanced model relationship techniques and custom joins and finders, and see how to use AppModel to consolidate repetitive logic across model objects.

In this session, we'll learn about controlling the flow of our application using callbacks and components. We'll explore the features of the CakePHP core components, and see how they can be used to secure our applications against different types of attacks, and show how to output our content in different formats.

We'll review what we learned today, and take a quick look at what's coming tomorrow.

Now that we have a functional application to work with, we'll examine how the console can be used to speed up development by generating files, testing queries and debugging requests. We'll see how to use the console to create our own custom tasks.

In this session we'll see how easy it is to set up a fully functional login form with authenticated controller actions. We'll show how you can customize the method of authentication, and as a bonus, implement OpenID authentication into the default login form.

This session will demonstrate how to use CakePHP's internationalization and localization tools to translate our application's content into different languages and locales.

Using console tools and poEDIT, we'll extract the content into a locale file, and use the new locale data to generate content. We'll also see how we can use the Translate behavior to localize database content.

Using the jQuery, we'll see how easy CakePHP makes handling requests and responses with Ajax. Building on previous sessions, we'll take a look at some advanced techniques for working with JSON, and finally, we'll demonstrate how to speed up page loads by building a custom Resource Helper.

Sign in, collect your pass, and receive your CakeFest info pack.

This talk will focus on the history of CakePHP and the reasons for its growth in popularity. We will examine all aspects of project management of open source software product, including the all the good and bad learned from CakePHP.

The goal of the talk is to inspire more open source development with the long term commitment to success.

Ever wanted to create an application that interfaces with a web service like Twitter, Flickr or Google Charts, but didn't know where to start? Have you asked yourself "does this go in a behavior? A component? A helper? Or what about these datasources I keep hearing the CakePHP developers talk about?"

This talk will help demystify how webservices can be integrated in a sensible, extensible and intelligent manner with your next CakePHP application.

CakePHP truly does allow rapid development of applications through it's many core features, offering diverse functionality from database query handling to form helpers, but none more so than the bake shell for code generation.

The ability to generate CRUD functionality, at the click of a button, directly from a database schema, is incredibly powerful, but really only the tip of the potential iceberg.

In this talk you'll gain intimate knowledge of the inner workings of CakePHP's core bake shell, tasks and templates, before discovering how to extend them to quickly generate full-featured code, customised to your exact requirements, that you can re-use project after project.

We'll use practical real world examples to illustrate these techniques, including simple customisations in view templates, and overriding model validation code to prompt for multiple rules per field and all the extra parameters.

Throughout there will be a sprinkling of the tips and tricks learned in over 2.5 years baking, that even the most seasoned of bakers should find interesting.

If your application needs to deal with lots of videos and images, you are faced with handling file uploads, generating different versions of content, and creating the markup to embed it.

This talk will show you by example how the Media plugin can assist you during each stage of a file from the initial upload to serving it.

The topics covered will be relevant for media-heavy applications, and will carefully examine uploads via HTTP POST, and how they can be secured and validated effectively and where the common pitfalls are.

Focus will also be given to the often time-consuming task of post-processing media files, and how metadata of files in various formats can be retrieved through an intuitive interface.

Starting a new project with CakePHP is easy. Setting up a development environment can be hard, though. Find out how easy it is to kick off a project with CakePHP using Assembla, and how to setup continous integration within the cloud. Participants will learn how to setup a project space with a svn or git repository.

We will start a server in the cloud and connect the repository with a continous integration setup directly within the cloud.

Topics covered:

- CakePHP

- Cloud computing

- Continuous integration

- Assembla

This talk will be delivered in bi-lingually, German & English, by popular request.

Want to dive into Git but you're not sure how or where to start? Get breakfast and head in early for a Git tutorial with the CakePHP core team.

Where will the future take us? Find out what's next for the CakePHP project.

This talk will demonstrate how to effectively create complex Behaviors using testing as a development tool. In addition, it will examine a process that helps us both achieve our goal and end up with a behavior class that maps to existing CakePHP behaviors, and is as compatible with others as possible.

The goal of the talk is to share some of the excitement discovered in moving the logic to the right place and code it in a way that makes sense. Hopefully by the end you will be on your way to write your own tests as part of development and realize the value of writing the API first.

This talk will introduce the audience to the concept of internationalization (i18n), and show how CakePHP allows coders to easily add i18n support to their application.

It will also show the tools used by the translators, as well as walk through the different elements needed to build multi-lingual applications.

This talk will cover the steps to build an API with CakePHP 1.2, by examining an actual specification received from a client, and showing how to implement it "the Cake Way". While not a fully RESTful API, it is an API that will also provide internal functionality for the site itself.

- Explanation: What, Why, How and Who

- Basic setup: the basics for the API like routes, models, controllers, views

- Error handling with HTTP response codes: setting up error handling with the right HTTP response codes and messages. What is useful for the developer that using the API?

- Authorization: from the website (basic Auth component usage) AND the integration of HTTP Basic authentication with the Auth component for the API

- Handling controller methods: highlights of some controller methods to understand initiating errors and results

- Setup XML serialize to give nice XML output: XML serialize in separate XML textnodes. How is it done in the CakePHP way?

- Using JSON view templates: short overview of using JSON view templates

- Initial testing with Java RestClient (http://code.google.com/p/rest-client/): how to test actions in the development phase.

- Building simple controller methods test cases: the why and how of building controller test cases for methods.

- Wrapping up, with additional information about the client and specification.

"But does it scale?" is a question that we hear bounced around quite often when discussing web frameworks. While a default installation of CakePHP is quite adequately configured to serve the needs of many developers, some applications need to serve a few (million) more page views than others.

In this talk, you will be taken through the different levels of progressive enhancment concerning application code, caching, database topologies and some general tips that will help your CakePHP application survive the Digg effect without a breaking a sweat, and go back asking for more.