November 10, 2015
You been working on this 10 year old business critical ColdFusion application and every release is a disaster. The business wants faster releases, but don’t want to perform a full rebuild from the ground up. In this session we’ll look at technics and tools that you can use to make it possible to perform Continuous Delivery (Also learn what this actually means) We’ll look at source control management strategies (SVN & GIT), getting your system under tests form the outside in with Selenium and from the inside out with TestBox and then we’ll join all this together for one click deployments.
What the Audience will learn
- You can bring your legacy application into the 21st century for low cost
- The benefits of being ready to release at all times
- Getting started with Selenium (It’s easier then you think)
- How to make your customers really happy
- How to make your developers extra happy
- How to make your support team even happier!
Audience will just need to have gone through the pain of a release that has gone wrong.
So you've looked at CF Components, and kind of understand the basics of how they work. Everyone says "frameworks are the way to go", but there's still a big knowledge gap between those 2 points. As each framework has its own terminology, how do you know where verbiage for one begins and the other one ends? Is "Controller" a Model-Glue specific thing? What about a "Service Layer" or a "View"? There's very little documentation available about the "Model-View-Controller" pattern for ColdFusion, that's not specific to a CF framework...and that's often what causes the confusion for people newer to OO development. In this talk we will go over a basic application that's built using the Model-View-Controller design pattern, but does not use any specific framework to get there. We'll also show when using the MVC pattern by itself may be enough for your app, when going to a full fledged framework may be the better way go to, and how easy it is to do so. For maximum benefit, you should have an understanding of how the CFComponent tag works, and we'll take it from there.
Description of target audience: Developers that haven't yet been able to bridge the gap from procedural code over to using MVC and discovering why frameworks are useful.
Assumed knowledge for the topic: People with an intermediate skill level of ColdFusion, and at least an initial look at the CFComponent tag. No prior OO/MVC experience required.
Objective for the topic: We'll give an introduction to the MVC design pattern, and separate out concepts and terms that are/aren't specific to a framework, showing how easy it is to go from one framework (or language) to another once you've got the basics sorted out correctly.
How do we go from procedural code and start writing OO code if we've never done it before? What's a Model? What's a View? What's a Controller? Are any of those terms specific to, say, Framework-1? Or are they generic OO terms? Is it any extra work to build an OO app instead of just doing things the "old" way? Let's look at an OO app both with and without a framework so we can see how similar they really are.
Mobile application can be a complicated task. With the mobile features build right into ColdFusion 11 the process has become easier. Local data storage, debugging, on application testing, creating a sellable application are just some of the basic features. This session will go over the features of a mobile application built using ColdFusion 11. We will walk through the pieces and parts that make all the hard parts easy. We will go over project setup in ColdFusion Builder. Then progress trough the basics of getting a mobile application built. We will also go over some of the core differences in building a mobile application in ColdFusion. What the audience will learn: 1: Mobile features in ColdFusion 11 2: Mobile application workflow in ColdFusion Builder 3: Things to watch out for when building a mobile application. 4: Mobile testing and debugging 5: Tips and tricks when doing mobile development with ColdFusion
"Most projects in CF now involve creating some type of consumable CFC Endpoint or API Service... do you Unit test your API, do you use Integration Tests on your API?
"Load Balancing, Scalability and Failover with ColdFusion
We will discuss and demonstrate how to design a scalable, high performing ColdFusion environment with a failover plan to keep your users seamlessly running even when a server goes offline.
We will look at using the built-in ColdFusion clustering features using local and remote peers along with setting up local and distributed web servers for IIS and Apache. We will talk about and demonstrate options with implementing a session replication strategy by using the client scope, distributed EHCache, and best practices with using in memory replication.
In addition we will look at some ColdFusion tuning tips which for the best performance. We will walk thru some must have ColdFusion server alerts and notifications as well.
Once we have our completed environment ready we will perform some load testing and demonstrate and monitor the seamless failover by taking one server offline and have the others cluster peers pick up the traffic without losing any session information."
"Often when creating mobile applications we only think of the user providing input to the app via their fingers, but with a large collection of sensors in a mobile device, should this be the only way? It is time to think outside the box when getting information from your users! In this session we will look at some of the different ways we can get input from users and look at some of the new techniques that developers are using. We will also look at other devices, like the oculus rift, and see what we can learn from other technologies. As well as looking at the theory behind this we will see how we can build some of these features with cfclient.
At the end of this session you will start looking at user input in a totally different way."
This advanced session will cover topics on how to leverage both CFML and ORM to start creating amazing applications that will be as lethal as a dinosaur riding a shark with an Uzi. We will cover ORM session management, virtual service layers, dynamic finders, dynamic counters and an enhanced Hibernate Criteria builder to create easy and programmatic HQL queries.
Come and learn, how you can make your migration process seamless and robust. What are the best practices to save hours and hours of struggle with Migration? The focus will be on challenges faced during Migration, such as Tips for migrating your web Application, Tweaks to migrate the Legacy application, role that connector configuration plays.
• Why is it important to understand the changes from JRun to Tomcat? • Why do we need CAR migration process and what are the benefits? • What role does Code Analyzer play in the migration process? • The challenges you may face post migration such as with Web service, Data Sources, Schedule Tasks and how to effectively handle them. • Common webserver errors (such as 500, 500.19, 401.7, 404.7) post migration and how to deal with them.
WebSockets are here. Are you taking advantage of this technology yet? If not, ColdFusion makes it really simple as of version 10. In this presentation I will cover how easy it is to get WebSockets working on your site. I will also cover real life pitfalls that I have encountered in my own applications, how to debug and overcome. Audience will learn
- How to setup WebSockets using ColdFusion
- Build a simple chat application
- Given a replacement for the Adobe provided test suite
- Given an enhanced Wrapper to deal with disconnection and connection drop not handled by CF's library to be able to take action and notify the user
"ColdFusion can do almost everything related to document management system with fraction of the price. Automating PDF workflow is number one priority for many companies. This session will explain the basics of workflow systems, PDF digital signature, and directory watcher. We will walk through how to implement basic workflow system with basic interface to manage and mentor the process in real time. Audience should have intermediate knowledge to work with ColdFusion and PDFs"
"As software craftsman, we need to make sure we have good tools. That’s what makes us productive, saves unnecessary work, and helps our teams work cohesively. Here’s where a lot of our tooling falls short:
Power and expressiveness Sharing and acquiring code with the community Productivity through automation
A GUI may provide the lowest entry barrier and initial intuitiveness, but it always comes with limits and restrictions to what you can do, and how easily/quickly you can do it. A Command Line Interface (CLI) is a common paradigm with a simple interface that can support any number of commands for all the common tasks you perform on a daily basis.
Sharing code and installing it is something we’ve done for years, but it should be easy, standardized, and scriptable. This is where a package manager comes into play. It allows you to quickly acquire the libraries you need while seamlessly handling any dependencies. And the best part of it being accessible via the command line is that you can script these installations and perform them over again at any time the exact same way. Even checking for new versions of all your libraries can be done in a single command.
A CLI, REPL, and Package Manager aim to help you be better, faster, and more powerful at everything you do. That’s why you should come get introduced CommandBox, a new CLI tool for CFML developers that does everything we just talked about and more. Go Commando!
Install and run CommandBox Use the REPL Use the package manager Use code generators Start up the embedded server Creating custom commands Using recipes
Previous experience with a CLI or package manager such as NPM will make these concepts more familiar."
This session would let you take a peek inside the ColdFusion engine. You would learn about the internals of the ColdFusion server that would equip you to understand and tune your applications better for higher performance. You would learn about • Detailed Lifecycle of the request • How a request is parsed, translated, compiled and processed. • How various scopes are managed and how they are resolved. • Various class loaders • Various configurations used in the request lifecycle and how they would impact the application.
"In his daily work of CF server troubleshooting, veteran CFer Charlie Arehart helps people solve problems that plague their servers, whether causing crashes, hangs, failures to start or stop, long-running requests, unexplained failures, including failures in applying updates, many of which nag and vex administrators (and often developers).
In this presentation, he'll present 10 of the most common and vexing challenges he's seen that plague most CF servers. More important, he'll present the solutions, all at a level that should be understandable by nearly anyone working with ColdFusion, whether administrators or not."
Using ColdFusion libraries we can now interact with noSQL database. We can manage data using ColdFusion structure and persist easily onto database.
A little about noSQL:
Due to the surge in web application usage, service oriented architecture adoption etc., the amount of data to be stored in database has grown by leaps and bound. It was difficult to manage this huge amount of data generated in SQL database systems, especially when it came to scalability and availability. This was majorly due to its design structure and its basic intrinsic nature to abide to schema which led to creation of noSQL database systems. NoSQL systems are simple in their design and store data in key-value, document or graph data structure . They provide good scalability, availability which are key for web applications along with many other advantages.
In this session, we shall know how to develop a web application using ColdFusion and noSQL, explore more on noSQL concepts, design and modeling of data.
Audience will learn : • NoSql database concepts with focus on few widely used noSQL databases • Its relevance in current web application development • Effective data models to support application needs • Interacting with noSql database using ColdFusion • Simple workflow and application development using ColdFusion and noSQL
Audience should know basic database concepts and have exposure to ColdFusion language constructs
Amazon Web Services (AWS) is well known to developers for providing a vast army of on-demand servers on which you can run anything, including Adobe ColdFusion. AWS offers a whole lot more than servers in the cloud, though. AWS is comprised of over 30 services which enable powerful Web/mobile application functionality and you can tap into nearly all of them using CFML. Adobe ColdFusion already comes with built-in support for Simple Storage Service (S3), but there's so much more you can do with ColdFusion and AWS. In this session, we'll look at:
- Delivering content for your web apps through Amazon's global content delivery service, CloudFront
- Sending SMS and push notifications through Simple Notification Service (SNS)
- Invoking on-demand Node.js task clusters through AWS Lambda
- Utilizing a high-throughput NoSQL datastore with DynamoDB