In our first session, we'll get familiar with CakePHP, and learn the basics of the framework.

- Setting up for development
- CakePHP project file structure
- Framework configuration
- CakePHP conventions
- Baking your first project
- Understanding scaffolding
- Using models
- Model properties
- Model associations
- Model validation
- Retrieving data
- Saving your data

Modelling and implementing advanced authorization patterns.

We'll begin with a simple application and extend it to have a system to authenticate users spanning more than one external provider. From this point we'll think about our user roles and implement an extensible system to allow only for certain roles to access our actions and records. This will be done leveraging the pluggable features of AuthComponent.

Use case: One user logs in with Facebook, while another logs in via the API, and both will be handed out different permissions.

Effective use of the events system: Injecting listener callbacks to any model in the system.

From this point we will prepare for the next part of the workshop by building an "events hub" for models. This will allow us to inject any logic into our models from library classes. We'll discuss the benefits and risks of using this approach, and code a few simple examples to test drive the new architecture.

Background processing: Extracting slow pieces of functionality to offline processes.

Now that we can attach events from the outside on models, let's explore processing tasks on the background to speed up our application. We'll come up with a time consuming task, such as indexing data in an external datasource or search engine, that we can offload.

Custom data sources: Using elastic search we'll build a CakePHP interface with a search engine.

Let's now take a look at how easy it can be to override a few methods in the framework to use a third party datasource. In our case, we'll try to save our data in Elastic Search and build a search function for our simple app.

In our second session, we'll continue to review the core aspects of the framework.

- Creating controllers
- Implementing callbacks
- Request and Response objects
- Components (Session, Security)
- Building views
- Page layouts
- Handling elements
- View blocks
- Helpers (Html, Form)
- Using plugins
- Debugging code
- Unit testing

Transforming model results via iterators: How to alter your data or extract info from it using iterators.

Having a search engine in place will allow us to do some extra data gathering and data manipulation. We'll create a result decorator to modify search results on the fly depending on the user currently logged in.

Advanced logging: How to extract useful information from your log messages.

Most people disregard logging as a vital part of their apps. In this section, we'll learn how to make a good use of logging, select a logging engine that won't kill your web server, and learn exactly what information to log.

Hardcore unit testing: Converting a badly designed code base into something testable, using mocks and alternative fixture handling.

We all write bad code sometimes, let's look at some techniques that will make your code look nicer and also make it easier to test. Additionally, we'll look at alternative ways of solving the fixture creation problem by using database migration.

Profiling CakePHP applications.

At the end of the workshop we'll use a few tools to profile the performance of our web app. We'll learn how to read and interpret a profiler's information and act upon it.

Keynote - Microsoft

Crud was built to be scaffolding on steroids, and allow developers to have enough flexibility to use it for both rapid prototyping and production applications, even on the same code base - saving you even more time.

Usually the basic code for controller CRUD actions is very simple, and always look the same - this plugin will add the actions to your controller so you don’t have to re-implement them over and over.

Crud also provides built-in features for JSON and XML API for any action you have enabled through Crud - that means no more double work maintaining both a HTML frontend and a JSON and/or XML interface for your applications - saving you tons of time and having a leaner code base.

Each developer must have their own development environment. Development environments may give you pain for building new, syncing with production, re-build on new laptop.

This talk will present how to create an ideal development environment on Vagrant.

This talk will show strategies for monitoring your server and application. Get notified when your server or application encounters problems. Also, the talk will cover some ways to centralize, parse, and analyze your logs when your application is running in multiple servers.

This talk would introduce the concept of design patterns in object-oriented programming, and review those which are used in the framework.

The patterns explained include:

- MVC
- Front Controller
- Template Method
- Factory
- Utility
- Active Record
- Decorator
- Singleton
- Strategy
- Adaptor
- Observer

The aim of the talk is to provide developers with a broader perspective when designing applications, allowing them to easily identify key areas where they can apply design patterns, and avoid fighting battles which have already been won.

While building Service Oriented Architectures, which require loose coupling and a clean and tested structure, you need to keep in mind that you should rely on very structured and decoupled frameworks, letting the door open for new integration and paradigms, like messaging queues or hypermedia-based webservices. But apart from this, are there any other things that we should keep in mind while going SOA? For example, how can you deploy your architecture if each service requires a few minutes to be deployed and your deployment mechanism can only deploy one service a time? How do you handle cross-service features in git, when you would need to create, review and integrate N pull requests that involve different services?

In this talk we will see how to avoid common hassles and mistakes while developing your own SOA.

I lead the development team at a Philly-based startup called WizeHive. Ever collect a lot of data in Google Spreadsheets, Wufoo, etc? Ever use Basecamp, Trello, etc? WizeHive fuses these two concepts, allowing you to collect massive amounts of structured data from both inside & outside an organization, and manage internal projects around that structured data. WizeHive is a really popular solution for scholarship & grant application processes, contests, etc.

Recently, we decided to re-imagine the technology behind the platform and build a REST API. We've been in production with Cake for a long time, but this next version will be released to production in July. Needless to say, we learned a lot. We wrote a ton of reusable code. And we finally decided - it's time we contribute back to the CakePHP community.

Over the summer, we will be open-sourcing some really cool plugins. And we were hoping that I'd get the chance to demonstrate those plugins and the lessons behind the API in general at this year's CakeFest.

Here's a taste of what I'll talk about:

* Input/Output Data Purification: ... is one of the first problem patterns you start to see evolve as you develop out a REST API. When you receive URL queries, you need to turn them into model conditions. When you receive input data, you need to convert it from the API format into something multiple models can understand and save. Rather than solve this problem in each individual controller, we created a couple highly abstract components - the `QueryComponent` and `InputDataComponent`. Using knowledge about how the API maps user-facing attributes to backend-centric model/table data, these components seamlessly convert most of our data.

* Permissions: ... become a huge issue. Relying too heavily on the ACL puts you in performance hell. But that doesn't make the ACL useless. It's a great backbone and we decided to use it as such. Using our setup, it is possible to get very fine-grained permission rules working in no time. Our entire app is now enforcing extremely complex permissions using one ACL-inspired component, and a handful of authorization methods per model.

* An Authentication & Authorization Protocol/Framework: For a variety of reasons, we settled on oAuth 2. And one of the first things we discovered was that, because oAuth 2 was relatively new, there weren't a ton of great CakePHP options for it out there. There was one popular plugin, but there were a slew of issues with it, not the least of which was a lack of any unit tests. So we rolled our own plugin. One of the neater things we accomplished with it was the creation of an `OAuth2Authenticate` adapter, which seamlessly handles oAuth2 authentication in a very Cake-friendly (read: non-hacky) way.

* Cross-Origin Resource Sharing (CORS): Many clients will inevitably connect to your REST API from another domain. CORS support is a must for every modern web application, but CakePHP does not deal with this out of the box. We created a dispatch filter which allows for efficient CORS OPTIONS handling.

* Documentation: We decided to use Swagger UI - https://developers.helloreverb.com/swagger/ - for documentation, and the biggest problem we wanted to solve was automating it. We now have a shell utility which, upon deployment, scans a variety of code - API attributes, validation rules, routes, etc - and parses the data into a highly readable & interactive documentation system.

As you can see, there are lots of valuable lessons here, and it won't hurt that we'll be open sourcing the result of some of them for others to explore immediately after the talk.

The CakePHP framework provides excellent tools to structure and organize server code -- making development fun and maintainable. Combining these tools with a solid Require.js implementation can elevate the often haphazard front-end development experience to the same level of excellence.

This talk will give a very brief overview of Require.js and it's benefits. It will outline a typical Require.js "Hello World" implementation. This will be followed by a more robust implementation for projects that are backed by CakePHP and have thousands of lines of javascript.

The talk will end with notes on configuring the Require.js optimizer to combine and minify the source for deployment.

Inveneo (www.inveneo.org) is a US 501c3 non-profit social enterprise that designs and builds long-range Wi-Fi networks in developing countries. Inveneo trains local entrepreneurs to operate these networks that deliver broadband to underserved communities in remote and rural locations in places like Haiti, Uganda, Kenya and Micronesia.

Inveneo uses CakePHP to support the design and operation of these Wi-Fi networks. The application, called Tower DB, helps track numerous aspects of our projects, from the physical locations where network equipment, such as routers, radios and switches, is installed to the actual configuration of the hardware. Tower DB has IP address management, multi-project and multi-permission support. Tower DB is also integrated with the OpenNMS network monitoring application and can provide a high-level view of each network’s status.

This talk will show how to deploy a CakePHP application with AWS OpsWorks. It will cover auto scalling by time range or server load, and how the load is distributed between the servers.

Bancha makes you faster in building client-server apps, pushing new features to production and helps to reduce product to market time. It allows developers to expose CakePHP models to Sencha Touch, a mobile web app framework, and to ExtJS, a desktop web app framework.
Come and join this session to learn about how server-side models are automatically mapped to client-side code and how models are set up with full CRUD[1] functionality, including remote sorting, filtering and pagination. You’ll learn about the framework’s rapid prototyping tools and how Bancha makes developing Sencha Touch and ExtJS applications easier and faster.

[1] CRUD: Create, Read, Update, Delete

With the move to cloud-based computing, writing applications that scale and scale well can be challenging. Many pre-existing CakePHP applications may not adhere to best practices regarding application development, deployment, and maintenance.

In this talk, the concept of a 12 Factor Application will be introduced, as well as ways to modify your CakePHP applications to better conform to the standard.

An overview of the Ember.js components, making direct comparisons same classes in CakePHP. Also a prepared demo of data bindings, live template updates and computed properties.

Scaling a CakePHP application is not only about CakePHP, but also PHP itself and how efficiently you manage your servers.

I'll provide some tips and tricks on how to optimize your application to run as fast and smooth as possible, as well as being able to handle an increasing amount of servers you'll scale, using puppet.

The talk will cover session and caching strategies, PHP settings, kernel and webserver tweaks and choices, and best practices for
squeezing the maximum performance out of your hardware.

The talk will be based on my real life experiences from setting up Nodes environment, exclusively running CakePHP apps, and how I managed to almost double the performance by spending a day tweaking settings.

This talk will discuss the professional development process we follow at CakeDC, and give people some insight on how we deliver projects for clients, the tools we use, the processes we follow, and the methods we apply.

The talk will cover the following topics:

- The free-to-work model
- Communication across time-zones
- Effective management and planning
- Development and QA strategy
- CakeDC git workflow
- Custom built CakePHP deployment
- CakeDC plugin development
- Case examples

Over the past year we've radically changed the company from inside out. Sharing the internals of CakeDC, and showing close-up how we work with the framework, will hopefully aid in helping people understand how we contribute as more than just a company. It should also put CakePHP under the spot-light as a success story, and clearly demonstrate it's potential as a vehicle for commercial success.

For years we've been used to the HTTP protocol, one of the reasons behind the web's success, a protocol able to scale up to billions of requests and beyond. But there's more we can achieve, taking advantage of HTTP/1.1 hidden features, having a look at HTTP/2.0 and SPDY, the Google-proposed new protocol which is already making web faster.

Back to the basics: what empowers and will empower the web?