TeraTech has been bringing you great conferences and even better software since 1989. We currently program in ColdFusion, SQL, and Visual Basic. Our mission is to provide high-quality software development and tools in the area of ColdFusion, Database and Visual Basic programming. TeraTech is a leader in the ColdFusion development field and has organized 25 national conferences over the last eight years.
This is the first list of topics accepted by CFUnited Advisory Board for 2007. More will be announced later. Including Flex and Scorpio Topics.
This will be an introductory-level presentation. You use Fusebox. You use CFCs (or maybe not yet). Do you wonder if you're going about it in the best possible way? Are the various "tiers" of your application properly structured? When it comes time to plug in a new functional requirement, do you automatically know where to position the various "moving parts" - circuit.xml, prefuseactions, CFC service layers, beans, complex return types? What about "facades"? This presentation will guide you in developing Fusebox 4/5 and CFC-based applications using best practices. You'll understand the differences and values of the various tiers. You'll be able to focus on solving the business application problem rather than wondering where to put your CFCs and how to call them.
Join Joe Rinehart, the author of the Model-Glue framework, to find out how Model-Glue 2.0 makes it easy to re-use application logic, both in other Model-Glue applications and through other technologies such as Flex and Web Services. We'll be discussing "Actionpacks," ColdSpring, and other best practices for building modular Model-Glue applications.
Most developers are well aware of our astonishing failure rate as a group: nearly 80% of software projects fail. Developers don't want to fail, but when the deck is stacked against us failure may seem inevitable. Even if we do manage to deliver an application, making changes to it is usually less appealing than a root canal. Rather than cross our fingers and hope for the best, it's up to developers to take control and turn the tide. Thankfully this can be much easier than you think. A simple change of mindset and a bit of agility training can help developers build applications that are successful in the short-term, and also are flexible and sustainable over the life of the application. Come to this session to learn how to build sustainable software using agile techniques in combination with frameworks. Though this session will use Mach-II as its framework, the techniques shared in the session apply to all development projects regardless of the framework used.
Embark down the Objectazon River with Peter J. Farrell, your jungle guide, on a design pattern safari. During the adventure, you'll learn all the basics you need to know about common object-oriented design patterns and how they are implemented in ColdFusion. You'll encounter real live objects in the wild - Beans, DAOs, Gateways, Services and other notable beasts. Begin your object-oriented journey with an experienced guide and collect safari loot for good questions. Don't get gobbled up by any objects!
We're used to the XML language of application frameworks being a static, fixed thing. If it doesn't let you do what you want, you're out of luck. Not so with Fusebox 5! This recent release lets you define your own verbs, which offers a much richer, more expressive way to build applications. This session will briefly walk you through the architecture of Fusebox and then dive into how to use third party custom lexicons as well as how to write your own language extensions. Enjoy the power of higher-level abstractions without the performance penalties they so often bring!
Regardless of the framework you use, the success of your application relies on providing users with what they want. But interviews, questionnaires, etc. simply don't do the job. Interface Driven Architecture does. Find out how to make your users delighted and your applications rock.
In this session I will introduce Aspect Oriented Programming and show how it can be used to aid programmers in the separation of concerns, or as described by wikipedia, 'the breaking down of a program into distinct parts that overlap in functionality as little as possible'. We will begin by focussing on a typical example of introducing logging code into an application through the use of cflog tags. Logging is often used as the prototypical example of a 'crosscutting concern' as a logging strategy can often affect code all throughout a system. I will then show how a logging system can be built using AOP, and in doing so, I will introduce all of the fundamentals of AOP, such as aspects, joinpoints, pointcuts, advisors, and proxies. If time and interest allows, I will showing a raw, code-centric application of AOP in order to discuss the core principles, and look at on some of the design patterns involved in building the coldspring.aop framework. I will move on to show how AOP methods can be applied declaratively via ColdSpring to simplify its use in a complex system. We will walk through adding multiple types of advice such as security and caching as well as logging to an existing system without altering any model code at all. I hope to end the session by introducing the AOP based ColdSpring Remoting, which will allow for the generation of remote facades for ColdSpring managed service objects, and discuss how this can be easily used for flash or flex based applications.
Talk about building well designed blog software with Mach-II.
Peter Farrell's done quite a bit of work with Mach-II plugins and filters, which is a topic that there isn't a whole lot of information on, so it would be great to hear him speak on how best to develop and use (and reuse!) plugins and filters for Mach-II.
Lays the foundations for a code generation system that encourages developers to model before they code. By making the model do more than fulfill documentation requirements, it becomes a more valuable tool for the developer. The blueprint for the application is generated at the start of the project, providing benefits across the development team. For organisations, model-driven development presents an opportunity to build-in standards and best practices. Senior developers and architects can focus on iteratively improving their generators to produce more code cleanly and handle mundane, repetitive tasks. Junior developers on the other hand are provided a great environment for learning and the structure they need to rapidly complete their projects.
Most frameworks for Coldfusion require an involved configuration, often using XML. Creating this configuration is both time consuming and raises the cost to entry for new developers to the framework. In addition to this these frameworks also require a developer to learn a separate API. However, a framework which uses intelligent defaults, metadata and relies on conventions can greatly reduce the learning curve and make developers overall more efficient. This session looks the advantages of developing applications using frameworks that require little to no configuration and employ auto-discovery techniques as well as how such applications are developed. Uses Ruby on Rails, Pylons and Grails as models for such frameworks.
The single most often-presented objection to using frameworks like Fusebox is the perception of extra work needed to comply with the framework's requirements. Ironically, one of the most powerful reasons for using a framework is the ability to use tools designed according to those requirements. Such tools can reduce the time required to perform the extra work from hours to mere seconds. This session will introduce several tools from GrokFusebox.com which leverage the Fusebox standard to help reduce the drudge work. Lazy programmers rejoice!
One of the most important elements of designing a software system is encapsulation. Many developers are leveraging the MVC pattern to organize their applications, often using a public or home-grown controller such as Mach-II, Fusebox, or Model-Glue. With proper care, one can design a model layer that is completely independent of the framework being used. This not only allows for more flexibility within the current system, but also for completely changing the chosen framework if necessary, with no change to the underlying model. This session will introduce MVC and provide tips and advice for encapsulating your model layer regardless of which framework you choose.
Are you new to Mach-II and want to get a jump on the basics behind the framework? Learn about what the framework will do for you, how the request lifecycle work and walk through working example code. Prerequisites: - Basic knowledge of CFCs - Willingness to learn!
This session will cover a basic introduction to Model-Glue.
Object Oriented Programming may be a new concept for ColdFusion developers. Learn about objects, relationship, wiring, and how to keep your objects organized. Session will wire objects manually, build an object factory and service locator from scratch, and use ColdSpring as a factory on steroids.
Benefits summary and introduction to the concepts of FuseBox 5.
Fusebox 3 is the world's most-deployed ColdFusion application framework. The core files have been downloaded hundreds of thousands of times. There thousands of Fusebox 3 applications in existence. Have you reached for the FB3 hammer dozens of times? Is fbx_switch like an old friend? Want to investigate the hub-bub of FB4/5? This presentation will showcase very common FB3 code snippets (and some not-so-common) and compare them to functionally similar FB5 snippets. This presentation will also cover reasons to switch to FB5 (and reasons not to) and provide next-steps for developers making the switch. Come to get your conversion questions answered!
Both BlueDragon and ColdFusion MX allow you to do object-oriented programming using ColdFusion Components (CFCs)--but what does that really mean? What's an object and how does it compare to a CFC? Most importantly, how do you objects to write better CFML code? In this presentation, Josh Adams will explain the core concepts of object-oriented programming and demonstrate how to apply them in CFML by using CFCs. Along the way, Josh will cover abstraction, encapsulation, polymorphism, and inheritance. BlueDragon 7.0 introduces abstract CFCs and interfaces and Josh will explain and use these new CFML features.
Anecdotal evidence suggests that the majority of ColdFusion developers got into web development without a formal background in programming. This means the CF community has a wealth of experience in many fields; it also means most of us don't know an object from a hole in the ground (programmatically speaking). This session will provide an introduction to object-oriented thinking specifically from the perspective of a procedural thinker. If you've always developed your Coldfusion projects from a sense of what the program needs to do, we'll soon have you working from a sense of what various objects need to do.
This would be an overview of the fundamentals of the Reactor ORM (Object Relational Mapping) framework. This presentation would include: -A quick review of ORM techniques -What Reactor is and isn’t -Supported database servers -The Reactor API (briefly) -Some examples (in code) -Getting Started / Resources -Questions and Answers I would also be happy to add some advanced presentations on Reactor such as customizing objects, using the iterator, cascading saves, validation, and more.
Been meaning to add testing to your development process? Come find out about the different tools to deploy your own framework for testing each layer of your application.
The Fusebox Lifecycle Process (FLiP) has been used by small and large teams to complete complex web application projects. It turns out that it also helps a great deal if you are a single developer. FLiP lends itself to an organized thought process, allowing a single designer/developer to methodically work through the myriad of issues in a large-scope web application development project. In this session, Christian Ready tells the story of how he employed FLiP to design and build a new web site for the US Air Force Auxiliary in Maryland (http://mdcap.org/). The FLiP process will be discussed and specific examples of how it was employed in this project will be provided.
Over the last 8 years, Fusebox has become the most popular of frameworks for Coldfusion developers, and deservedly so. This session introduces the concepts of Fusebox, including its file organization and naming conventions, centralized controller, and XML-based configuration files. We'll use the Wegot Widgets reference application to demonstrate and discuss the essential aspects of Fusebox 4 and 5. Bring your questions--this one will be as hands-on as we can possibly make it.
We've all seen how tools like RoR and MG:Unity can create great demo sites in minutes, but usually when you're building real projects you have to dump the scaffolding and start from scratch. In this session we'll look at how richer metadata can allow you to generate 80-90% of most of your web applications - with better quality than hand written code.
ColdFusion components are an application framework themselves. With a little bit of organization and careful planning, it is entirely possible to gain the benefits of other popular frameworks such as Fusebox without requiring dozens of core files, framework overhead, or the need to learn another XML language. Using CFCs as the framework allows developers to focus on the study and design of business objects and methods rather than being bombarded with sales pitches and heated debates regarding which framework is better than the others. The simple methodology in this presentation is based around standard MVC (Model, View Controller) concepts. The original implementation was designed by John Quarto, Hal Helms and Jeff Peters specifically for the Fusebox 4 framework back when CFCs were just gaining+E18 momentum. Steve has recreated this light-weight MVC approach using nothing but CFCs and some simple core application logic.
Do you work with the "creative" sorts? Do your designer friends scoff at your wayward attempts at design? Learn the secrets your design friends don't want you to know. Learn how designers use visual hierarchy, color theory, and good old fashioned page layout techniques to make great looking web pages. Gather the knowledge to convert your projects from merely functional to intuitive and attractive in just a few minutes. Learn how to take advantage of those framework templates with some simple tips and tricks, and put those design posers in their place.
This session will provide developers with techniques and approaches to successfully plan the "look and feel" of their applications. There is the proverbial grey zone where the designer stops and the developer starts, that area is what we will address with this topic.
• Using Photoshop and Fireworks in real life- The bare necessities (image manipulation, special effects etc.)
• CSS - No more stinking tables! (Best practices, and using DIV, positioning, making templates, CSS drop shadows, and to add navigation effectively to easily change your site's appearance)
• Putting it all together - Real life examples of dynamic styling using Model-Glue and more.
Frameworks are good, but do you need to update to the newest one? Or when is it good to update? Or what about your teams? Are they really ready to update?
Spry is the new Adobe framework for AJAX. It was intended for designers, but the ColdFusion Community has adopted it with open arms. This presentation will discuss what Spry is, how and when it should be used, how developers can leverage ColdFusion to make Spry more powerful, and cover how Spry and Flex can co-exist.
In this session you will learn what ColdSpring is and how it can help you make your applications, regardless, of what frameworks they use, better. A sample application AppBooster will be used to demonstrate the advantages ColdSpring provides.
Rails is clearly one of the hottest web development frameworks around. What can those of us working in languages other than Ruby learn from the Rails framework? Come find out.
Many of us have heard of Simon Horwith's anti-framework called SAM. Unfortunately there exists very little documentation, samples, or implementations of SAM and therefore it is rather difficult to grasp and to learn. As a witness to the creation of this "methodology" and the standards that make it, I'd like to offer a practical tutorial on SAM, not only as an alternative to frameworks but as a supplement to them.
SOS is a persona based framework. That means that it has separation of content and presentation. When a developer writes apps he doesn't mess with the design. Design is separated into skins that go beyond CSS alone. SOS shares authentication and presentation so the apps built can be installed without rewrites to adapt the site look and feel! Another collaboration aspect of SOS is the fact that you can use one of the three included methodologies or create your own plugin. SOS has a shared API to help prevent broken links and maximize code reuse. There is more but you are going to have attend to see why we think this is so cool!
How do you test your apps? What methods work best for testing? Share how you stamp out bugs in this testing roundtable.
Can the concepts that led to the development of web application frameworks also provide insight into how to deploy a web application? Come find out about frameworks for deploying and maintaining web applications in any language that support security, stability, scalability, and performance metrics using open source and off-the-shelf tools on Windows and Linux.
In the real world of development, all the solutions that you create have a life cycle.
To know when to use some kind of framework, can really help to achieve the desired quality, and speed.
As the cycle can be broken into: planning, develop and support, how can a Framework help or not?
How a framework can or cannot complete the 5 main tiers of an application: Client-side, Server-side presentation, Server-side business logic, Server-side domain and integration tier? The use of some examples, for common problems could help a lot (example: