Well the first day of Scotch '08 is now over, so here is a quick round-up of the sessions I attended.
First was the opening keynote, by Ben Forta and Adam Lehman.
A lot of talk about CF8 doing very well, and not much about what will be CF9, Codename Centaur.
They also claimed Adobe was going to be more open with it's bug reporting, feature requests, and will be doing various other things as part of their 'Open Process Initiative', which will be good if they happen.
Much of the keynote was a demonstration of LiveCycle Data Services and how ColdFusion and Flex can utilise this.
Overall, Adobe seems to be steering ColdFusion into a middleware position, between Flex/AIR and LiveCycle.
One thing to note is that Adobe EMEA now have a ColdFusion contact, Claude Englebert.
Session 1 : General OO, by Matt Woodward
In this session Matt Woodward covered some of the key points of Object Oriented programming.
He covered Cohesion, Coupling, Inheritance, Composition, Polymorphism, Encapsulation, Data Hiding.
This session was mostly nothing new to me, but it's was nice to solidify my understanding.
Session 2 : Requirements & Estimations, by Peter Bell
I enjoyed this session - it was well structured and presented, and I found it interesting and a useful way of looking at things.
The presentation was on how Peter Bell helps determine requirements and produce estimates on how long implementation might take, based on Audiences, Objectives, and Use Cases, but not forgetting the underlying Business Intents.
I have mixed feelings about lunch. It was organised in the hotel's restaurant/breakfast area, and everyone's place was set with the starter.
The starter was a plate of salad and a bread roll - I don't like leafy food, so my starter was the bread roll.
For main course, it was self-service, also with a fairly limited choice.
The only meat was chicken, which was with mushrooms in a sauce. I like chicken, but I really dislike mushrooms, so this was not good.
The pasta and sauce was okay, and the potatoes fine, but nothing else was that appealing - I like straightforward food, not half an attempt at fancy stuff.
I hope tomorrow has a better selection.
Session 3 : Getting Dynamic with CF
The third session of the day was Sean Corfield discussing some of his methodologies with regards to dynamic ColdFusion.
One of his main points was that ColdFusion has more in common with Ruby/etc than Java, and we shouldn't feel constrained by thoughtless application of strict typing.
He referred to Design by Contract - if something is capable of fulfilling a request (ie: calling a function, or being passed to one), then allow it to do so - don't bother testing whether it might be able to or not, because you don't necessarily know in advance.
On the whole, I vaguely agree with the concepts of his talk, but his actual implementations seemed to add a great deal of layers to reasonably simple things, resulting in something that would be hard to follow if you didn't already know what it was doing.
A useful reminder from the talk was to look at ColdMock or CFEasyMock, which are simple mock object frameworks, to help with unit testing.
Session 4 : LiveCycle ES
The fourth session I attended was on LiveCycle ES. This is a Service-Oriented Architecture running against J2EE, for user-centric and document-centric services.
It is targetted at simultaneous interaction with multiple clients, multiple systems, and so on.
It's distinguishing feature seemed to be that it had a visual editor, however because a server in Canada was down we didn't get to see the demo (???).
Whilst it seems in some ways interesting, I'm still not sure what specific practical benefits it might offer. However there is a beta on Adobe Labs which I may have a look at.
Session 5 : Model-Glue Gesture, by Joe Rinehart
I attended the Model-Glue session in an attempt to see if I can 'get' Model-Glue at a "why do I want to use this" level.
Whilst some of the talk was interesting, discussing Joe's motivation behind Model-Glue and some new features in the third version of MG, I still don't find myself 'connecting' with the way it works.
The first day ended with a presentation / discussion by the OpenBD Steering Committee.
With the license changes that came with ColdFusion 8, many people are finding the upgrade costs prohibitive and starting to consider other options, and despite this being the last session of the day there was a fair number of people there.
One of the core areas that the OpenBD Steering Committee want to focus on is that of packaging entire applications as J2EE WAR files, and even entire packaging entire servers into OS images. For commercial software this then shifts the focus away from charging for code and onto paying a subscription for support/maintenance for those that want it. The other key advantage is in getting CFML out into the world, without necessarily having people needing to choose to use it - in the same way that people simply use many pieces of PHP software regardless of it being PHP, it is hoped that soon CFML software can work in this way also.
It will be interesting to see how this develops.
I missed the first session for Thursday, partly as none of the three choices interested me, and partly because I got up late.
Session 2 : Designer/Developer Workflow in Flex, by Andrew Shorten
Although I don't do Flex, and I'm not yet convinced of its merits, I am interested in finding out if it might be useful for me.
This talk was about how developers and designers can work together to produce Flex apps that look much better than the standard skin, and whilst it was interesting to watch, and good to find out the options for styling Flex, I'm yet to be won over by it.
Session 3: Railo 3, by Gert Franz
Today Gert announced the new Railo 3 Beta, which is now available on the Railo website.
This new release of Railo will bring compatibility with most of the new CF8 tags, attributes and functions.
There are also several new tags and functions which are currently unique to Railo, and a number of very interesting features.
Task Manager is the first new feature. This will be a spooler in the administrator for checking on mail, threads, instance synchronisation, scheduled tasks, etc.
This allows you to see if mail has failed, monitor running threads, and so on. The tasks remain between restarts, so they can be retried after the server has been bounced.
Railo 3 has added support for a new scope: Cluster.
As is hopefully obvious from the name, this scope is shared across all instances in a cluster - which does not need to be a local server - it could be another machine elsewhere on the web.
cfvideo and cfvideoplayer have finally arrived, with an impressive set of features.
Firstly, cfvideo which is for processing and converting video files. You can convert between formats including flv, mov, avi, mpeg, mp4, even animated gif!
You can also extract images from specified frames, or the mp3 audio track from a video.
There are predefined profiles for internet, youtube, iphone, zune, and more.
It supports 1080p, 1080i, 720p.
Both divx and xvid are supported.
Unfortunately there is a catch to all of this - it requires xfmpeg which for licensing reasons cannot be distributed with Railo, it needs to be downloaded separately.
To accompany this new video processing is the cfVideoPlayer which allows you to actually play the videos in a browser. This can play a simple video, or it can play many videos, with playlist support and the ability to merge videos.
Because video processing can be intensive, it is recommended anyone wanting to do a lot of this investigate the Amazon EC2 and S3 services, which Railo can easily connect to using Resources, so you can rent the EC2 processing power to convert videos and the S3 storage space to keep them online.
A slight improvement over yesterday, but similar frustrations at the choice of food. Whilst it was still salad, there was at least effort put into presentation of the starter today, rather than dumping leaves onto a plate. I had potatoes and carrots mainly, with a little bit of rice that had been spoilt with some mixture of something. The desert was a very nice cheesecake.
For the Railo Keynote after lunch, the atmosphere in the room grew as Gert Franz took the stage with a guy wearing a RedHat baseball cap. He was introduced as Luc Texier from JBoss, and then the annoucement was made: Railo will be joining JBoss.org and going completely Open Source.
This is fantastic news, not just for Railo but for the entire CFML community - opening the doors between the CFML world and the Java world - and was greeted with loud applause from the whole room.
I will be talking more about this in my next entry Railo goes Open Source with JBoss.org.
The rest of the talk was Luc and Gert introducing the features which JBoss will bring to Railo, and mentioning that things like Hibernate and JBoss Cache are likely to be implemented as built-in Railo tags.
JBoss Clustering will bring a high availability framework and services to Railo. With fail-over, replication, load-balancing, zero-config, auto-discovery, fine-grained optimization and tuning, it presents very powerful options with incredible ease of use.
There are many other JBoss technologies potentially available - what happens will depend on what the Railo community wants.
The next year and a half is going to be a very interesting time for Railo.
Session 4 : AIR & Aptana, by Mark Drew
I hadn't planned what event to attend after the keynote, but lingering in the room afterwards resulted in my choice being made for me.
In his talk, Mark Drew demonstrated how AIR apps can be created easily with Aptana and jQuery. I have dabbled slightly with AIR in the past, but have yet to explore its potential, and it was interesting to see the wizards which Aptana supplies to ease the initial setup of AIR apps.
Mark was building an AIR-based Twitter application, intending to demonstrate the ability for AIR to seemlessly switch between online and offline modes, storing data and re-sending when back online. Unfortunately his efforts were thwarted by the notorious WatchGuard proxy blocking access to Twitter.
Session 5 : Unit Testing and Automation, by Neil Middleton
Neil's presentation was primarily on Unit Testing, focussing on MXUnit, but also mentioning Selenium and demonstrating Cruise Control and the MXUnit Eclipse plugin.
Unit Testing is a critical and yet often missed part of any serious development, and it will be good to experiment myself with MXUnit and either Cruise Control or Atlassian Bamboo - the latter of which can integrate with the Jira issue tracker we use at work.
ColdFusion 9 BoF
This session involved Jason Delmore and Adam Lehman fielding questions on possible features for the next release of ColdFusion, codenamed Centaur and not yet permitted to be called CF9.
Once we got past the initial topic of extending cfscript, it was interesting to hear the issues people have with ColdFusion and CFML, and for Jason and Adam to respond directly to them. It was nice to see that Adam was noting down each of the feature requests made.
I again missed the first session today, not through choice, and it was a pity because from talking to a colleague it sounds like Sean Corfield had a very interesting approach which could fit well with the applications we have at work.
Session 2 : Building Hybrid Applications with ColdFusion and Java, by Jason Delmore
Jason began with a useful point to make, since making the jump from C++ to Java, ColdFusion has not been an application server, but is simply a Java-based RAD application. His point here was, I believe, that both CF is not Java, but we can and should make use of it when it benefits us.
Jason introduced the various methods for interacting with Java, and told us: "Don't use Java CFX tags, ever". There is no benefit to them compared to the other options now available.
He discussed JSP tag libraries, such as the Jakarta taglibs Project, Google Tag Library, JCE TagLib (Cryptography), and others.
He demonstrated the Jakarta string libraries, showing their ability to do title case (capitalise first letter of every word), word-wrap to a fixed character width, and more.
He also discussed that Strings are an immutable object, and thus things like concatenation are very slow, as three objects need to be involved.
For operations involving hundreds or thousands of iterations, he recommended using StringBuffer instead, which is essentially a String but mutable, so you can simply append new strings without creating extra objects.
With JDK 1.5 there is the new StringBuilder, which is similar to StringBuffer but a little faster - although StringBuilder is single-threaded.
He demonstrated how to use these with his ColdFISH syntax highlighter.
It's not just Strings, and Jason also covered the 'hidden' functions behind Queries that you can tap into.
At one point he mentioned that CFCs are not yet serializable in CF, but implied that this wil be fixed in Centaur.
He also pointed out several APIs included with ColdFusion that can be used: ANT, iText, POI, Log4J, AXIS, JAI.
A key point he made is that these are not documented features, but there is no reason not to use them - if they are removed from CF in future versions, you can always manually include the JARs yourself.
Session 3 : RAD OO, by Peter Bell
Next up was Peter Bell, discussing various tools and techniques he uses.
XML Config - this was about writing your Controller steps in pure XML - not in the way that Mach-ii or Model-Glue do, but directly putting the application workflow into the tags and attributes, then using either dynamically at runtime, or with code generation, producing the relevant code to make this work.
Base Classes - this is a simple idea, rather than having individual classes for all your objects, simply produce a small number of base classes which are extended
Optional Classes - following on from the above, rather than having multiple classes, or even extending the same base class, the idea is you only have physical files for objects which use non-standard behaviour, so if you see a CFC you know there is overridden behaviour in it, rather than having a lot of empty files and not knowing if there is different logic without opening the file.
Iterating Business Object - this is Peter Bell's way of applying accessors to recordsets (query results), with the idea that instead of looping through a query then having logic in the view to handle exceptions, you convert the recordset into an IBO and then have the logic hidden inside the CFC methods, rather than having it in the view.
Smart Views - this is a simple idea - for certain exceptional pages, allow the View layer to access the Model directly without going through the Controller, as it can make things easier to read and write.
RAD Model - this idea goes back to the Base Classes concept, with Peter Bell proposing a single trio of Service/DAO/Business for the whole model.
RAD View - I have this noted down, but don't have any details on the explanation. :S
Custom Data Types - here the idea was to have various customised data types implemented with functions for display(), field(), process() allowing you to format output display, field input, and process the data types. For example, a phone number is ultimately a list of numbers, but it can be useful to present to users with parenthesis, hyphens, and so on.
Lunch today was almost a disaster for me. Again, another salad starter, but the best main course option almost seemed to be scraping mustard sauce of some sausages. Fortunately I was rescued by them bringing out some more potatoes, and I had some brocolli also. After sitting down again, I noticed someone else had found Macaroni cheese, and I went and found that and got a generous helping. Dessert was okay, a large slice of heavy carrot cake more than filled me up.
Session 4 : OpenBD and Tomcat, by Nitai Aventaggiato
In this session, Nitai discussed the setting up on OpenBD on Tomcat. He pointed out a useful way for ensuring there is enough RAM, by changing the java-opts rather than the catalina opts (which get overwritten at runtime), and he has promised to write more details about this on his weblog.
He also said that they had found an Open Source option for cfdocument in OpenBD, using PDFBox.
Session 5 : Complementing CFML with Open-Souce Java, by Joe Rinehart
This session was about what Joe called the 'next level' of frameworks - that is, delving into Java and making use of things such as Hibernate and Spring. Whilst there are already CFML equivalents (Transfer+Reactor and ColdSpring) that are easier than the Java ones, there can be cases when the extra power of Java is a useful tradeoff.
The conference ended with a big thank you to all the sponsors, the speakers, the organisers, and everyone who helped make Scotch a great success. There are of course plans for Scotch to return again next year, even bigger and better than it was this year. Roll on Scotch 2009. :)