Speakers

New speakers:
  • Brian Kotek
  • Brian Meloche
  • Brian Rinaldi
  • Dan Wilson
  • John C. Bland II
  • John Mason
  • Kurt Wiersma
  • Laura Arguello
  • Oguz Demirkapi
  • Ron West
  • Samer Sadek
  • Todd Sharp
  • plus many others!

Sponsors








Badges

Help us promote the conference by placing a promotional badge on your site!

cf.Objective() 2008:
The Only Enterprise ColdFusion Conference...

Frameworks : A-Z Track

ColdBox Framework 101 - Luis Majano

ColdBox is a proven MVC event-driven CFC based ColdFusion Framework. ColdBox is a solid software foundation on which you can build your applications on. It provides you with a set of reusable code and tools that you can use to increase your productivity, and it provides you with a development standard that comes in very handy when working in a team environment. It makes use of an MVC (Model View Controller) design pattern implemented via CFCs, conventions and an extensive array of patterns for its operations such as Factories, Cache, Helpers, Workers, etc. And since it is based on Conventions it does not rely on an XML dialect, convention over configuration. Get ready to learn about this next generation ColdFusion framework and Development Toolkit.

Advanced Techniques With The ColdBox Framework - Luis Majano - two hour hands on workshop

This talk will cover advanced topics on building applications with the ColdBox Framework.

  • Interceptors - ColdBox interceptors increase functionality for applications and framework alike, without touching the core functionality of your application. This pattern wraps itself around a request in specific execution points in which it can process, pre-process, post-process and redirect requests. These interceptors can also be stacked to form interceptor chains that can be executed implicitly. You can also create your own execution points and implement an observer-observable pattern in your applications. You can then announce interceptions from anywhere from withing your ColdBox Application.
  • Request Context Decorator - ColdBox uses a request collection data structure where all variables can be stored and shared among a user's execution request. The object containing the request collection is the request context object. This object contains several methods to help you get values, set values, set views, layouts, get the current event, and much more. If you need to go above and beyond what the framework provides, you can decorate the object with extra functionality you might need by using the request context decorator.
  • Caching - ColdBox comes with a dynamic cache solution that will help you increase your application's speed and persistence. We will cover how to use caching for data, objects, views and even event caching. How to tweak the cache for optimal performance, its eviction policies, interception points, its best practices and its caveats.
  • ColdBox Proxy - Need to create multiple interfaces for your applications HTML/FLEX/AIR? Need to monitor your applications? Need to create a flex event-driven model? Then the ColdBox Proxy is the feature for you! The ColdBox proxy let's developers create remote and web applications sharing IoC Frameworks, ORMS, common security, logging, state management facilities, and much more.
  • Custom Plugins - Learn how to easily create your own plugins for re-usable operations, UI elements and much more.
  • Core Plugins - Discover the ColdBox plugins and see how they can help you build your applications faster, configure software aspects and much more.
  • Tips & Tricks - Tips & Tricks on the internals of ColdBox, things you might never know about!!

ColdSpring 1337 - Chris Scott - two hour hands on workshop

This session is aimed at the advanced developer, who does not simply use ColdSpring because the CF Weekly told them to, or because it is used by Model-Glue. We will take a deep down look at how ColdSpring gets its job done, from startup to shutdown. We'll examine the bean creation life cycle as well extension points in ColdSpring that most people don't even know exist. We'll talk about different uses of custom factories, from simple factory beans, to implementing custom factories via the factory interface as well as how you to extend ColdSpring classes to create a customized version of ColdSpring's RemoteFactoryBean. Finally we will review the many new features of ColdSpring 1.2 including parent and abstract beans, bean aliases, collection factories, and new cfcUnit components which help you simplify testing your managed components.

Introduction to FarCry 5.0 - Jeff Coughlin

Learn the basics of the most recent version of the FarCry framework. This presentation will demonstrate the ever popular FarCry CMS plugin as well as show how easy it is to add and deploy other plugins offered by the FarCry community. We'll also demonstrate some of the new features specific to the 5.0 framework and discuss how your clients can benefit from them.

Driving Fusebox 5.5 - Sandy Clark

Fusebox is the oldest and most widely used framework in the ColdFusion programming community. The creators of Fusebox began promoting the use of the MVC (the Model-View-Controller) design pattern with the release of version 4. Unfortunately, not everyone understands MVC, and many people refuse to understand the benefits when applied to a Fusebox Web Application.
The aim of this session is to take MVC Fusebox out for a "test drive" using the newest Fusebox release, 5.5. This session will introduce MVC, point out its strengths and weaknesses and build sample applications starting from an MVC-less application and then re-creating it in MVC. Both XML Fusebox as well as the new xml-less version will be used. Special attention will be paid to using CFC's as the model in the design pattern as well.

Enterprise Development With Mach-II: Modules, Plugins, and Filters - Matt Woodward

Do you know the basics of Mach-II but are looking to take your Mach-II development to the next level? Are you confused about the differences between filters, plugins, and modules and when to use these? Then this session is for you! Come learn all about the ins and outs of plugins, filters, and modules, what problems they solve, when you might (and might not!) want to use them, and just how easy all this really can be.

What's New in Mach-II 1.6 and 2.0 - Peter Farrell

Learn what's new in Mach-II 1.6 from event-level caching to message publishing. Find out about our new development tools, request debugging and our dashboard module that provides administration of your application from reloading it to managing the new caching. Also, come to find out about the new features in Mach-II 2.0 which will be in prerelease in May 2008.

Introduction to Model-Glue - Ray Camden

This is an introduction to the Model-Glue framework. Basics will be covered but time will also be sent looking at real world Model-Glue

Model-Glue 3: Back to its Roots - Joe Rinehart

Three years ago, the Model-Glue framework brought easy but powerful MVC development to the ColdFusion community. With the release of Model-Glue 3 (code named "Gesture"), the framework's going back to its roots. Model-Glue 3 is will make it easier than ever to employ architectural concepts like MVC and Implicit Invocation in your ColdFusion applications. Join Joe Rinehart as he gives an overview of Model-Glue development, the new features of Model-Glue 3, and the revamped internals of the framework itself.

Reactor: Deliver Thyself Away From Iterators - Doug Hughes

Ever wonder why some parts of your Reactor application perform terribly? I bet I know why... Iterators! That's not to say that Iterators are always the problem. However, Iterators are tempting because they allow you to be lazy. The problem is, they have to do so much behind the scenes that they get unwieldy quickly and bog down your application. Thankfully, there are some techniques you can use in your reactor application that may actually be simpler than using Iterators and which will help your application's performance. We'll cover some of these techniques and discuss other ways to help your Reactor application's performance.

Introduction to Building Applications with Transfer ORM - Mark Mandel

When developing an Object Oriented web based application, it is normal to have a database with relational tables and a series of objects that represent that data. Often, the amount of time and effort it takes to manually map these objects back and forth from a database is large, and can be very costly.
Object Relational Mappers (ORM) were developed to cut down the amount of time this process takes, and automate the translation between a relational database and an Object Oriented system.
Transfer ORM's main focus is to automate the repetitive tasks of creating the SQL and custom CFCs that are often required when developing a ColdFusion application. Through a central configuration file Transfer knows how to generate objects, and how to manage them and their relationships back to the database.
This presentation will outline the basics of what an Object Relational Mapper is, the use case for using one within web application development, as well as taking a code centric, step by step view of how to install, configure and use the basic functionality of Transfer ORM.

Transfer ORM Caching Mechanics - Mark Mandel

One of the most powerful features of Transfer is it's highly configurable, in-built caching layer that can allow for significant performance gains for a given application when configured correctly.
Caching concepts such as 'caching algorithms' and 'memory sensitive caching' will be covered so that as a Transfer Developer, you have a better understanding of what is going on 'under the hood'.
This will also include a discussion on the various cache configuration options that are available with Transfer, and the use cases that these configurations can apply to, and the various APIs that are available that allow you manipulate what is in cache and work with, and around it as necessary.

Best i18n Practices with Frameworks - Oguz Demirkapi

This presentation will explain the basics of creating multi-language applications and methods in ColdFusion and best practices on frameworks usage. The main goals will be to explain the theory behind multi-language applications, defining requirements and solutions, and providing best practices with code samples. Presentation will cover best practices in Fusebox, Model-Glue, ColdBox and FarCry.

Some points that will be covered:

  • Explaining the theory for i18N (internationalization), L10N (localization), g11N (globalization) and other known approaches.
  • Defining opportunities to create effective solutions on frameworks (Fusebox, Model-Glue, ColdBox and FarCry).