The amazing adventures of Doug Hughes

Archive for October, 2007

Validat 101 :: Data Definitions :: Part 1

A couple of weeks ago, we introduced an open source project we have been working on at Alagad called Validat. If you missed the announcement, Validat is a data validation engine for ColdFusion applications. Validat is designed such that it can be dropped into any application with a minimal amount of customization, and perform any data validation needs for that application.

As the documentation is being updated for Validat, I wanted to make a few postings hitting on some of the big concepts behind Validat. First on that list is what is called data definitions.

Intro to Data Definitions

So, what is a data definition? Part of the problem with developing a validation engine that works for any application is that every application has different data in different formats (forms, beans, etc.) and validation rules to be applied to that data. In order to address this, the Validat data validation engine makes use of a data definition that maps various validation rules to specific data elements.

Data Definitions via XML

The Validat data validation engine allows you the developer to configure the data definitions in two ways – one of which is an XML configuration file. The Validat XML configuration file is broken into two parts – validation rules and data sets.

Validation Rules

The validation rules segment of the XML configuration defines the validation rules that can later be applied to various data elements. An example configuration snippet looks something like this:

     <!– validation rule definitions –>
    <validationRules>

        <rule name="alpha" validator="validateAlpha" />
        <rule name="alphaNumeric" validator="validateAlphaNumeric" />
        <rule name="length" validator="validateLength">
            <arg name="min" value="0" />
            <arg name="max" value="100" />
        </rule>
        
    </validationRules> 

The root element is validationRules and contains one or more rule child elements. Each rule element has a name for reference to later on and a pointer to a validator bean. This validator bean name must match a bean that can be requested from the ColdSpring bean factory (by default).

In addition, default arguments may be passed to the validation rule. Default arguments could be things like a min and max value as shown above, a minimum age, or any number of other possibilities. These default values may also be overridden later on in the dataset definition as well.

Data Sets

The data sets segment of the XML configuration defines one or more data sets (who would have thought!). A data set is simply a collection of data elements. A data set might represent a collection of form fields that will be validated together or it might represent a bean object and its associated properties. By defining data elements in collections, you may apply validation rules not only to individual data elements, but also to the data set as a whole. An example of a data set definition is shown below:

     <!– data set definitions –>
    <dataSets>

        <dataSet name="user">

            <dataElement name="firstName" required="true" message="errors.validation.user.firstName.required" >
                <assert rule="length" >
                    <!– optionally, additional arguments can be provided to the validator function –>
                    <arg name="min" value="1" />
                    <arg name="max" value="100" />
                    <message name="invalid" value="errors.validation.user.firstName.invalidLength" />
                </assert>
            </dataElement>
            <dataElement name="middleName" required="false" >
                <assert rule="length" >
                    <arg name="min" value="1" />
                    <arg name="max" value="100" />
                    <message name="invalid" value="errors.validation.user.middleName.invalidLength" />
                </assert>
            </dataElement>
            <dataElement name="lastName" required="true" message="errors.validation.user.lastName.required" >
                <assert rule="length" >
                    <arg name="min" value="1" />
                    <arg name="max" value="100" />
                    <message name="invalid" value="errors.validation.user.lastName.invalidLength" />
                </assert>
            </dataElement>

        </dataSet>

    </dataSets>

Every data set in XML configuration file must have a uniquely defined name and contains a collection of child data elements. The name data element was chosen instead of data field or other term because of the flexible nature of a data element. A data element is not limited to a form field. Instead, if you are validating a bean, a data element could actually be a property of that bean. If you have a structure of data that needs validating, the data element could represent a key/value pair in that structure. Flexibility is the name of the game.

For every data element, a unique name is defined (within the data set) and a required value flag is set. If the required value flag is true, then a message attribute must also be provided. The message attribute value is what is returned in the event that the data element is required and does not contain a value. In the example above, the message attribute value is a resource bundle identifier for localization, but it could easily be any text string.

For every data element, there are one or more child assertion elements. An assertion is simply a validation rule being applied to that data element. The rule attribute of the assert element specifies the name of the validation rule mapping from the validation rules section of the XML configuration file above. In this example, we again show how arguments can be passed to the validation rule as well as a message to be returned in the event that the assertion fails. An assertion may run multiple tests on a given data element, so multiple messages may be specified, each with a unique name.

Up Next …. Programmatic Data Definitions

In some cases, having a hard coded data definition via XML is not the best route to go. For example, if a form is dynamically built, then it is possible that the data validation rules would be dynamically assigned as well. Validat takes this into consideration as well with a comprehensive API allowing the developer to programmatically create and update a data definition. In the next article, we will take a look at this API and what it offers the developer.

Tabbing To Select Menus on a Mac

I recently bought a nice Macbook Pro. (Yes, I drank the kool-aid, at long last.) This post is not about the Mac nor the nearly painless transition. Instead it’s about one of the small annoyances I found. It seems that, by default, OS X does not want you to be able to tab to select menus in forms. Instead, the next form element after the select menu will be given focus.

This drives me insane as a web developer. Imagine trying to build and repeatedly test a form with any number of select menus and, for each select menu, being required to take your hands off the keyboard to drive your mouse to the menu, open it and select the item, before going back to the keyboard.

On Windows I could always just click tab and the next form item would be selected.

It turns out that there is a simple OS setting for this. Simply open System Preferences, Select Keyboard & Mouse, and select Keyboard Shortcuts.

allControls

Just click “All controls” towards the bottom and you’re good to go.

SilvaFUG Presentation on Flex Frameworks

I don’t typically watch recorded presentations because I’m easily bored and often pretty busy… but this one caught my eye, mostly because MG:Flex was going to be reviewed.

http://admin.adobe.acrobat.com/_a200985228/p12266504/

First thing of note: they didn’t give high marks to MG:Flex yet, but they said to keep a strong eye on it because they found the concepts to be interesting and the framework to be worth taking note of. It was cool to see someone "outside the family" comment on work done by "one of us"… good job Joe!

Second thing of note: they give a really good (if very high-level) overview of Flex frameworks that will challenge your notions… and the presentation is scattered with some other interesting technical discussion and the QA section at the end is fascinating. It may irritate you, it may challenge your notions, it may make you think. The only thing I can say is that it wasn’t a waste of my time.

Enterprise ColdFusion with Model-Glue Training Available

Alagad recently launched a new corporate website.  (Not like we’ve kept this a secret or anything.)  As a part of this launch we’ve begun the process of introducing Alagad training programs.  A few people have noticed and asked us for more information.  So, here’s a quick rundown.

So far, we’ve only announced one program, Enterprise ColdFusion with Model-Glue.  We’ll be introducing more before long.

The Enterprise ColdFusion with Model-Glue training class is a four day, hands on, class taught.  Those who attend will get a wide range of materials which should be of use to teams who are contemplating moving to Model-Glue.  We cover everything from the basics (and details) of CFCs to the Model-Glue framework in depth, to other supporting technologies including CFCUnit and ColdSpring.

Check here for more details on the class.

We can deliver this class either onsite or offsite.  We already have a few instances of this class scheduled at client facilities for early next year.

This leads me to my question to you: Where should Alagad hold offsite classes?

I have been considering the DC metro area, Chicago or Detroit, somewhere around the Bay Area in California, and Denver.  Do you have any other suggestions? 

I’m also open to training overseas.  As far as I know there’s no one else doing this.  I’m happy to fill this void and travel wherever I’m needed.

Over the next year I hope to introduce some other classes too.  Is there a training class that’s missing in the industry?  Do you want to learn more about ColdSpring or Mach-II?  Server Tuning?  Maybe Ajax technologies?  Anything else come to mind?

Using Eclipse Working Sets Instead of Workspaces

One of my biggest gripes about Eclipse has always been the use of workspaces to organize projects. For example, I had a client not too long ago for whom I had several Eclipse projects created. I had at least three projects for frameworks alone. Then I had the legacy application and the new application we were building. I’m sure there was at least one more in there too.

Now, it seems like the most widely known way to separate this from your copious list of other projects was to create a Workspace. The problem with workspaces, however, is that to switch between workspaces you must start a different instance of Eclipse. That doesn’t mean you can’t have multiple instances of Eclipse running with different working sets, but it can be a hassle none the less.

So, last time I saw Paul Kenny he, as usual, brought to my attention something which I previously had no idea existed: Working Sets. Working sets are really just collections of projects.

As an example, here’s a long, unorganized list of projects:

projectList

As you can see, there’s no organization here. Seeing as I’ve been doing a lot of work on the Alagad.com site, it would be nice if I could see only the relevant projects. To do this I first click on the menu arrow and click Select Working Set…

workingSetMenu

This shows me the Select Working Set dialog.

newButton

Seeing as I have no working sets I’ll create a new one by clicking the new button. This shows the New Working Set dialog.

resource

For my projects I’ve been selecting Resource (or Java – I can’t see the difference between the two) and clicking next. In the resulting dialog I can select the projects I want in my working set.

projects

Finally, I click finish and I am returned to the Select Working sets dialog where I now see my new Working Set.

selectedWorkingset

If I select my working set and click OK my project list will refresh to show only the selected projects.

workingSetFinal

This is a really handy way to have Eclipse show only what I’m most interested in at the moment. Now that I have my Working Set created I can also quickly deselect it on or off though the same menu we started with.

deselect

Data Warehousing Part 2 Dimensional Modeling

First of all I should apologize for the long delay between this article and the preceding one which discussed the differences between On Line Transactional Processing (OLTP) and On Line Analytical Processing (OLAP). At a very high level OLTP databases are those used in typical day to day processes, inserts and updates etc and involve what is known as “normalization” which is used to avoid data duplication, here is a good clear overview of normalization.

OLAP databases store historical data and are typically used for producing reports, analysis etc. Data Warehousing projects are almost always based on an OLAP design. After that short revisit we can now move on the the next process in creating a Data Warehouse. At this stage a process known as “Dimensional Modeling” comes into play. Typically we will be considering using data in a data warehouse for Business Intelligence (BI) purposes; reporting being a major part of that. If one of the main purposes of normalization is to avoid duplication of data; at a simple level that is not a key need in a data warehouse. One reason is that we should never make changes to data directly in a data warehouse. We may pass updated data in from the OLTP database copy but never update it directly in the data warehouse. Dimensional modeling of data involves these main constituent elements:

Dimension:

A dimension can be considered to be a category of information. For instance a geographical dimension.

Attribute:

An attribute is an identifiable constituent part within a dimension, for instance a country.

Hierarchy:

A way of relating constituent parts within a dimension relating to their level, for instance country >city >state >zip >longitude and Latitude. The data elements in a data warehouse are contained and associated in a different way to their state in a OLTP database.

There are two main “containers” which are represented as database tables:

The Fact Table:

We use the fact table to hold the “measures of interest” as required by the business-organizational users. For instance in an application measuring traffic patterns number of cars would be a measure of interest. The level of granularity, which is an important consideration in designing fact tables, is, determined by, in this example, the required sampling intervals of the data. For instance are the number of carssampled hourly, daily, weekly etc? As an example if we were analyzing a busy junction we might want the number of cars each hour at that junction in that case the fact table could contain four columns

  • Number of Cars
  • Date
  • Time (hourly)
  • Longitude and Latitude

The lowest level of granularity in this example is the Time attribute. Discussion with users to determine their requirements is a critical need in effective data warehouse design. Ideally the team designing a data warehouse should also have some knowledge of the needs of a particular sector as this helps in identifying elements that may be overlooked by users. As we mentioned, granularity is a very important part in getting the fact table design right.

The Lookup Table:

The look up tables represent one dimension in the model and contain attributes for each dimension. Typically there will only be one link to each look up table, the fact table is the only table with multiple links one to each look up table. In a basic data warehouse design there in one fact table which joins to multiple “Look Up Tables”. If we imagine the fact table in the center with look up tables around the fact table this is where the term “Star Schema” comes from.

Star Schema

Dimensional modeling of data involves these main constituent elements:

Dimension:

A dimension can be considered to be a category of information. For instance a geographical dimension.

Attribute:

An attribute is an identifiable constituent part within a dimension, for instance a country.

Hierarchy:

A way of relating constituent parts within a dimension relating to their level, for instance country >city >state >zip > longitude and latitude.

Summary:

Dimensional modeling is a somewhat abstract principle and one that is very requirement specific; needing to be created for specific business-organizational user needs. It is becoming increasingly more importing particularly in driving the needs of organizations to plan; based on historical information. There are some guiding principles to bear in mind.

  • Data should not be updated or changed directly in the data warehouse.
  • Look up tables should contain only one link per table.
  • Fact tables can contain multiple links one to each look up table.

Use Simple Factories and Inheritance to Reuse Code

Introduction

Recently, in a mailing list I’m on, the question of code reuse came up. Someone wanted to decide at runtime which of two classes to extend in order to share the common code for the job (which was most of the code) across two slightly different implementations. The problem with that, however, is that you have to use a string literal for the extends=”” attribute of the cfcomponent tag. There is, however, a fairly simple solution that accomplishes the same thing.

Let me give a brief overview of the solution and then get into details.

When you’re using the extends=”…” attribute, what you’re really doing is saying “all my common code is in the class I am extending”. We can also call the class we’re building on the “base class”, which is actually a term I’ll be using a lot in this post. So, the process is this: write your base class that contains all the common code you have, then write two other CFCs that specify the base class in the extends attribute. These two CFCs should also take into consideration whatever differences there are that require you to have 2 classes in the first place. That takes care of sharing code between two slightly different implementations. The question then becomes “how do I determine which class to use when I have to do the work that my 3 new CFCs allow me to do?”

The easiest way is to use a simple factory class. This means a CFC that has only 2 methods: init() and getInstance() (or something similar). You could also simply specify a cfif block somewhere in your code that would allow you to create an instance of the right CFC, but that’s a “code smell” red flag that screams “I’m gonna have these cfif blocks all over my application, or have to re-run them on every request!”

That’s not good. So… let’s get on to some sort of real example. What to use, what to use?

We could use creating a data source under CF 6.1 with one class and CF7 or 8 using the AdminAPI with the other, but that’s entails a great deal of code and I think the idea would get lost in the process. How about a simple set of CFCs for reading a text file into a query?

That’ll work.

So what do we need? We’ll need four components:

  • BaseQueryParser.cfc
  • WddxQueryParser.cfc
  • CvsQueryParser.cfc
  • QueryParserFactory.cfc

BaseQueryParser.cfc

BaseQueryParser.cfc is the base class for our query parsers and contains all the common code that the implementation classes (or child classes, or extension classes, or any of several other names) will use to do their jobs. It looks like this:

<cfcomponent name="BaseQueryParser" displayname="BaseQueryParser">
	<cffunction name="init" access="public" returntype="factories.model.data.BaseQueryParser" output="false">
		<cfargument name="qryData" type="string" default="" />
		<cfif len(arguments.qryData) GT 0>
			<cfset setQueryData(arguments.qryData)>
		<cfelse>
			<cfthrow message="Argument qryData cannot be an empty string!" detail="#qryData#" />
		</cfif>
		<cfreturn this />
	</cffunction>
	<cffunction name="getQueryTextAsQuery" access="public" returntype="query" output="false">
		<cfthrow message="This is a base class." detail="You must extend BaseQueryReader and implement a working version of getQueryDataAsQuery()." />
	</cffunction>

	<cffunction name="setQueryData" access="private" returntype="void" output="false">
		<cfargument name="qryData" type="string" required="true">
		<cfset variables.qryData = arguments.qryData >
	</cffunction>
	<cffunction name="getQueryData" access="private" returntype="string" output="false">
		<cfreturn variables.qryData />
	</cffunction>
</cfcomponent>

Pretty basic stuff. Init() method for initialization, a default method called getQueryTextAsQuery() that throws an error if called (because we don’t want people actually using this one, just the other two), and get/set methods for the string that will be turned into a query.

Take a note though: any code in this class will be used by the other two classes. And, just to make things more interesting, methods that the other classes implement (like init() and getQueryDataAsQuery()) don’t just overwrite these in memory… they exist in a special scope called “super” and can be used by calling super.init(), for example.

Which, in fact, we do in our very next section…

WddxQueryParser.cfc

And now, for you to behold, is the first of BaseQueryParser.cfc’s two children:

<cfcomponent name="WddxQueryParser" displayname="WddxQueryParser" extends="BaseQueryParser">
	<cffunction name="init" access="public" returntype="factories.model.data.WddxQueryParser" output="false">
		<cfargument name="qryData" type="string" default="" />
		<cfset super.init(argumentCollection=arguments)>
		<cfreturn this />
	</cffunction>

	<cffunction name="getQueryTextAsQuery" access="public" returntype="query" output="false">
		<cfset var qryData = getQueryData()>
		<cfset var qry = 0>
		<cfwddx action="wddx2cfml" input="#qryData#" output="qry" />
		<cfreturn qry />
	</cffunction>
</cfcomponent>

Take note of how much less code this CFC has than the other one… just two methods. It implements getQueryTextAsQuery()… but look at the init() method. It actually calls super.init()… so we’re not just sharing whole methods here, we’re actually sharing particular bits of functionality, like loading the “instance data” (in this case the WDDX string that will become a query) into the variables scope. It was only written once… but now it’s being used here.

Next!

CsvQueryParser.cfc

<cfcomponent name="CsvQueryParser" displayname="CsvQueryParser" extends="BaseQueryParser">
	<cffunction name="init" access="public" returntype="factories.model.data.CsvQueryParser" output="false">
		<cfargument name="qryData" type="string" default="" />
		<cfset super.init(argumentCollection=arguments)>
		<cfreturn this />
	</cffunction>

	<cffunction name="getQueryTextAsQuery" access="public" returntype="query" output="false">
		<cfset var qryData = listToArray(getQueryData(),chr(10))>
		<cfset var i = 0>
		<cfset var r = 0>
		<cfset var row = "">
		<cfset var columns = qryData[1]>
		<!--- assumes first row is the column list --->
		<cfset var qry = queryNew(columns)>

		<cfset columns = listToArray(columns,",")>
		<cfloop from="2" to="#arrayLen(qryData)#" index="i">
			<cfset row = listToArray(qryData[i],",")>
			<cfset queryAddRow(qry)>
			<cfloop from="1" to="#arrayLen(row)#" index="r">
				<cfset querySetCell(qry,columns[r],row[r])>
			</cfloop>
		</cfloop>
		<cfreturn qry />
	</cffunction>
</cfcomponent>

Note, again, the minimalistic approach taken to code here… only enough to do the specific things that changed between the base class and this one… so only getQueryDataAsQuery() and init() are here, and even init()’s the same as init() in theWDDX version.

QueryParserFactory.cfc

But now the real fun begins! Now we get to create the class that will allow our application to use these three CFCs seamlessly… enter the QueryParserFactory component. Check out the code:

<cfcomponent name="QueryParserFactory" displayname="QueryParserFactory">
	<cffunction name="init" access="public" returntype="factories.model.data.QueryParserFactory" output="false">
		<cfreturn this />
	</cffunction>

	<cffunction name="getQueryReader" access="public" returntype="factories.model.data.BaseQueryParser" output="false">
		<cfargument name="qryData" type="string" required="true" />

		<cfset var reader = 0>

		<cfif find("wddx",arguments.qryData)>
			<cfset reader = createObject("component","factories.model.data.WddxQueryParser").init(arguments.qryData)>
		<cfelse>
			<cfset reader = createObject("component","factories.model.data.CsvQueryParser").init(arguments.qryData)>
		</cfif>

		<cfreturn reader />
	</cffunction>
</cfcomponent>

Check out the middle… when you call this component’s getQueryReader() method, you pass in whatever string you’re needing query-ized. It figures out which CFC to return to you, instantiates and configures it, and returns it… BOOM. It couldn’t really get much easier for your application.

You can use something like this to check system settings, environment variables, any number of different things, and return the right CFCs for the job, configured and ready to go, just like that. It all comes down to using inheritance and a factory to deliver the correct child class.

Summary

I’ve written a little sample application to go with this post, and you can download it below. It has an index.cfm file that reads in some text from a WDDX and a CSV file and uses the factory to get a query from each of the child classes… so you can see this in action.

I hope this was helpful!!

QueryParserFactory Example

An Apple A Day (and a walk) Keeps The Doctor Away!

This is very much an OT post but I just thought I would share what I think is a really neat piece of technology from Apple and Nike. I walk a lot when I have time, the furthest I have walked non-stop so far is 27 miles, just one over a marathon when I think about it. This is on a beach path which starts effectively in Hermosa Beach CA and goes on for a good few miles North.

Recently I purchased a new pair of Nike running shoes, Shox Turbo V+ if anyone is interested. It turns out that equipped with a an iPod Nano and a sports pod created in partnership with Nikewe can now get feedback on the time taken, distance ran or walked, the rate (how long it would take to walk a mile) and with some tweaking calories burned.The signal is shoe to a small dongle plugged into the Nano. In additionwe can get spoken commentary as to the status of the run-walk at any time and of course also play music or videos, try not to walk off a cliff whilst watching videos though. There is also a website where we can then upload and store results and set goals etc.

Ibelieve this to be a great use of technology; to produce something that hopefully encourages more exercise, which has to be a good thing.

ColdFusion Error: corrupt table

As Scott has been blogging here, we recently released a new Alagad.com website built ontop of Farcry.  The thing is, since we released the site we have been  having intermitant problems with errors cropping up in the admin interface which simply say "corrupt table".  We quickly discovered a few points about this:

  1. There are no corrupt tables.  Or, more to the point, our data in our database was not corrupt.
  2. If you restart ColdFusion the errors went away.

I initially assumed this was a but with Farcry and put it on my list of things to fix.  Today I spent some time actually looking into the problem and, after trying to rewrite a part of the Farcry core, I realised that Farcry has nothing to do with this.  It turns out to be a bug in ColdFusion 8.
I found a discussion related to this on the Adobe forums.
It seems that the cachedWithin attribute on cfquery has a bug which will eventually produce this problem in some sites. 
The problem was supposed to be addressed in the first cumlative update, but for some reason was not.  It is now slated to be released in the second cumlative update.  Watch this page for more information.

At Last All In One Place The (growing) Family, Flash

This blog piece is intended for business users in the main but I hope will also serve as a good information point for pulling together ever expanding array of Flash based technologies. For some time there has been an evolving need to break through the strictures of HTML development to bring desktop like functionality to essentially web-browser-based application development and to allow efficient interactions between desktop and web based applications.

HTML base elements such as forms, tables etc. have been stretched way beyond their limits and constructs such as iFrames, DHTML and even Ajax are all examples of attempts to break through the HTML barrier. They can all suffer to one extent or another from three ongoing flaws, if not used carefully:

  1. Browser Compatability They are all very browser specific and this can and often does introduce unpredictable behavior in different browsers. Typically this is mitigated by mandating a single browser type or family; in the open Internet this is not practical. Here is an excellent article on some of the problems encountered by applications developed which rely heavily on the use of JavaScript, such as Ajax – http://blogs.zdnet.com/Stewart/?p=101
  2. Application Scalibility Those of us who have used JavaScript for formatting large resultsets will no doubt have noticed how JavaScript slows down perceptibly as the recordsets get larger. Ajax, for instance, introduces interactions with XML or JSON in the browser moving part of the server-side operation to the browser client. This can significantly impact application performance as the size of the XML passed becomes larger. Here is a good article detailing this http://searchwebservices.techtarget.com/originalContent/0,289142,sid26_gci1162641,00.html
  3. Application Security This is a very good article detailing some of the security implications affecting sophisticated JavaScript applications such as Ajax http://www.securityfocus.com/news/11456

Flash Based Options

The Flash family of options brings us a complete suite of possibilities not only to produce sophisticated GUI’s in a Web Browser but also on the computer desktop and in devices such as PDA’s, phones etc. With the potential release of “AIR” (currently still in beta) we will get the capability to allow full real-time interaction between the web browser and the desktop. Here is an overview of the Flash family of products.

Flex

Outside of the Flash Player itself Flex is the most relevant development in the evolution of Flash. Flex is a way of dynamically creating Flash SWF files at run-time. Initially Flex (I.0, 1.5) was an expensive server-side paradigm that created dynamic Flash objects, aka SWF files, using MXML, a version of XML. With the advent of Flex 2.0 (the current released version) there was a decoupling of some of the parts of Flex into the following constituent parts and the addition of other elements.

Flex Framework

This is a series of classes programmed using ActionSript 3.0. ActionScript is the programming language for Flash based applications. It is very similar syntactically to JavaScript or ECMAscript. MXML is used to describe screen layout and produces ActionScript at runtime.

Flex Builder

Flex Builder is an IDE based on the Eclipse IDE and affords an easier way to get up and running with Flex. Flex Builder 2 makes developing Flex applications much simpler with features like an integrated compiler, code hinting, debugging, design view, source control system integration, and many other features. Flex 3.0 is currently still in beta and there are some significant enhancements from Flex 2.0, more details here.

Livecycle (Formerly) Flex Data Services – Enterprise Services 2

Deployed as a standard J2EE application, LiveCycle Data Services enhances the client-side Flex framework by providing high-performance connectivity with existing server-side data and business logic. Based on a robust messaging architecture, LiveCycle Data Services integrates with existing common middleware and provides services that automatically synchronize data between client and server, adding support for real-time data push and publish/subscribe messaging, and enabling collaborative and occasionally disconnected applications.

Flex Charting

Flex Charting software provides a rich library of interactive charts and graphs that enable rich data dashboards and interactive data analysis. Dynamically rendered on the client and with full support for the Flex data-binding and event model, the charting components make it easy to add drill-down, rollover, and other interactivity that makes your charts even more insightful than before. All of the charts can be extended to provide additional functionality, or developers can use the base classes to create customized chart types. Simple Flex client-server diagram…

Flex

Flash Lite

Flash Lite is the Flash technology designed for mobile phones and consumer electronics devices. Flash Lite dramatically accelerates the delivery of rich content and browsing, and customized user interfaces. There have been two major versions released so far; Flash Lite 1.x and Flash Lite 2.x. At the time this paper was created both versions were still being shipped by phone-device vendors*. Flash Lite 2 distributions will play Flash Lite 1 content but not vice-versa. Adobe recently announced the imminent launch of Flash Lite 3. Here is another simple diagram showing how-where Flash Lite might be used…

Here is a table showing the differences between Flash Lite version 1.x and 2.x

*There is a list of supported devices here with which version is supported: http://www.adobe.com/mobile/supported_devices/handsets.html

Flash Video

It is astounding how quickly Flash Video has come to dominate video on the Internet. There are estimates that as much as 70% of video delivered via the Internet uses the Flash Video format (.flv) and that has happened largely during the past two years. From Flash Payer 9 update 3 the Flash Player will support the MPEG-4 standards based high definition format.

Flash Cast

Flash Cast is a complete offline portal solution that enables the delivery of interactive content and branded data services to devices such as cell phones that are highly personalized, as well as easy to promote, discover, and use. Flash Cast enables consumers to subscribe to the “channels” of their choice, such as news, sports, music, and more. Content is delivered proactively so it is always available on the device regardless of network coverage. Here is another simple diagram showing how-where Flash Cast might be used…

Flex Flash Lite Flash Cast

Air – Adobe Integrated Runtime (Formerly Apollo)

The Adobe Integrated Runtime (AIR) is a cross-operating system runtime being developed by Adobe that allows developers to leverage their existing web development skills (Flash, Flex, HTML, JavaScript, AJAX) to build and deploy rich Internet applications (Rich Internet Applications – RIAs) to the desktop. The runtime also enables interoperability between desktop and web based applications. Adobe AIR beta introduces support for the open source, cross-platform SQLite database, local file system dialog boxes, drag-and-drop support, major performance enhancements to the HTML component, and more. There are a growing number of sample AIR applications which can be seen here.

Connect – Formerly Breeze

Adobe Connect, derived from the product formerly known as Macromedia Breeze, is a secure, flexible web communication system that enables IT professionals to support and extend the functionality of Adobe Acrobat Connect Professional to provide enterprise web communication solutions for training, marketing, enterprise web conferencing, and online collaboration. It has features such a desktop sharing and remote control and runs without needed additional software downloads using the Flash Player as the client. This new version of Adobe Connect has an extensive range of API’s which are now industry standard; using web services to interconnect. This means that integration with ColdFusion or LiveCycle-Enterprise Services is possible with theoretically minimal pain. Here is another simple diagram showing how-where Connect and AIR might be integrated…

Flex Flash Lite Flash Cast AIR

New Flash Based Adobe Offerings

I apologize if this sections is somewhat lacking in details, most of these technologies are evolving as I write this.

CoCoMo

CoCoMo will be the next-generation framework for the Adobe Connect Web conferencing service, which will enable developers to take certain parts of Connect$#39;s functionality and integrate them into other applications.

Kuler

Kuler is the first web-hosted application from Adobe Labs designed both to stand alone and to complement Adobe Creative Suite software. Built using Adobe Flash and ActionScript 3.0, kuler is all about color: color for exploration, inspiration, experimentation and sharing. More information about kuler can be found here.

Pacifica

Pacifica is a service that will allow developers to integrate voice, messaging and user presence information into applications built using Adobe Flex, Adobe Integrated Runtime (AIR) or Flash technologies.

Share

http://labs.adobe.com/technologies/share/

  • Send documents without email attachments.
  • Access your documents from anywhere.
  • View all the documents you have shared or received in one place.
  • Post a link to your document on a wiki or blog.
  • Embed a Flash preview of your document on any website.
  • Limit access to a document to a list of recipients.

There is a lot going on with the Flash Family at present and we will be keeping an eye on how this will affect our clients and also help them to fully realize all potential benefits.

Tag Cloud