Holm Log

LiveCycle Data Services and Offline Data Sync Management

bruce — Fri, 25 Jul 2008 02:23:29 +0000

by Adobe evangelist Ryan Stewart

Adobe LiveCycle Data Services (LCDS) allows keeping/managing data sync’d between a server and a client that goes offline.

BlazeDS is free open source server product, runs on Java servers for chat type apps
Data Management (DM) and sync are not covered by BlazeDS
Use LiveCycle for DM
Configuring your server “destinations”

data-management-config.xml
- RTMP or AMF channels used
- properties specified, id, what to get back
services-config.xml

set up how to send data across AMF, RTMP, etc
set the server host or public server, idle timeout

3 parts to a simple online/offline app

DAO functions
Assembler functions (send back/forth)
Custom Data Type (for sending complex data)

At this point Ryan gave a demo of a waypoint data storage handler.

Scorpio 8 Preview

bruce — Tue, 01 May 2007 23:15:49 +0000

Attended the local Adobe RIA User Group Meeting last night to hear an official tour Adobe rep present a preview of Scorpio (ColdFusion 8 ) features and benefits. He broke his presentation down into three areas of focus:

Developer Productivity
Integration
Management and Administration

Developer Productivity Features

CFIMAGE tag - based on full Java image support functionality

Attributes include: border, convert, info, read, resize, rotate, scale, etc
50 additional image related functions
images treated as their own object type

CFAJAXPROXY tag - simplify CFC invocation from AJAX

Uses JSON or XML for data consumption
AJAX wizard provided
Yahoo UI fully supported for

rich grid, rich tree views
dual select lists, auto-suggest, FCK editor available

CFWINDOW tag - supports HTML and JS

provides popup window
can be positioned, typical attributes used

CFLAYOUT tag - includes support for multiple CFLAYOUTAREA tags within

Improved file I/O

~14 new functions
much easier read/write to files, less cumbersom
CFLOOP file=”" index=”line”
CFLOOP file=”" index=”char” maxchar=150 (as I recall)

CFDOCUMENTS tag enhanced

supports bookmarks and bookmark hierarchy
support for page count, page number, section page count

CFREPORT tag enhanced

support for templates and CSS styling
conditional formatting - reveal sections based on specified conditions
output to HTML or PDF

CFC Interfaces

Argument collection - act as default tag organizational structure

Implicite array and struct creation

Use more PHP like syntax
CFSET myArray = [”apples”,”oranges”,”pears”]
CFSET myStruct = [fname=”Joe” lname=”Cool” age=35] (as I recall)

Full support for JS operators

++, –, ==, !=, etc.
Within CFSCRIPT… >, <, <=, >=, etc

CFCs now serialized properly (replicated correctly)

CFFTP tag now supports SFTP

Integration

.NET assemblies supported - local and remote via .net proxy

MS Exchange - Mail, Calendar, Contact, Task

CFPRESENTATION tag - on demand presentations

content can be PP slides, any SWF supported content, MP3 audio
dynamic content such as graphs and charts

Flash Media Server Gateway

bi-directional connections - transfer between FM and CF
media and data streamed
allows interactive media player creation

PDF manipulation

metadata, merge pages, extract pages, encrypt, create thumbnails
flatten PDF for archive and smaller size, protection security
full DDX instruction set supported (very powerful)

PDF Form Manipulation

pre-populate PDF based forms
extract PDF form data for post-processing and insert into database
new PDF scope synonymous to current FORM scope
JS form validation support

Management and Administration

Major improvements

Multiple user based accounts support

roles and scope of access definable
access based on sandbox settings

Server Monitoring - based on

activity, requests, usage details, load
server snapshots possible
save state
FLEX based UI - fully customizable
<18% overhead when activated in full detail modes

Server Alerts -

set based on

thresholds based on load, memory, threads, etc
definition of unresponsive server, slow server, etc
amount of JVM memory usage
number of timeouts allowed

response

send email
run CFC - get more details, kill threads based on age, reject new requests
snapshot or server status included in email

API provided for full programmatic access
Alerts thread isolated from other threads and memory for more sure activation

Expandable Rows - Ch. 3 Bulletproof Web Design

bruce — Fri, 22 Dec 2006 23:39:12 +0000

Chapter 3 in Dan Cederholm’s book “Bulletproof Web Design” discusses how to design a section of the web page that normally is one text row tall (such as a login, search, crumbtrail info, or bulletin notice) and allow for the inevitable occurrence where it needs to be two or more text rows but still not break the design. You may have rounded corners or other graphical icons/elements that look great when one row of text is present. But what happens when your crumbtrail becomes two lines of text or the announcement line becomes two lines instead of one… does the graphic elements get misplaced? If nested tables are used to layout this section of the page, then it likely will.

Once again CSS is used to design a lean yet flexible and efficient piece of code that accomplishes the same look as the table-based design but using the right technique it is possible to allow for expanding text content. Dan takes an example of a Login / Find line and an announcement line with rounded corners and icons embedded and re-works the code to hardly any code yet it ends up looking nice and achieves the goal of having an expandable text area.

Scalable Navigation - Ch. 2 Bulletproof Web Design

bruce — Fri, 22 Dec 2006 01:16:22 +0000

Chapter 2 of the book by Dan Cederholm “Bulletproof Web Design” is on how to build solid website navigation that is flexible and uses very efficient code yet looks good. Starting with the common way header navigation has been done in the past with tabs made from multiple sets of images, he does a makeover making the tabbed interface look as good or better yet uses a fraction of the code required in the old method.

The tabs still have rollover highlighting along with gradient background and beveled edge yet provides a way for the user to scale the text size and still have the tabs enlarge proportionately and look good. He walks through the technique to implement in CSS and then discusses why it’s bulletproof. He ends the chapter with examples of other tab styles such as the rounded corner tabs of mozilla.org or the slanted tabs of www.simplebits.com

Flexible Text - Ch.1 of Bulletproof Web Design

bruce — Fri, 22 Dec 2006 01:04:50 +0000

Started reading the book “Bulletproof Web Design” by Dan Cederholm. This book takes the web standards based approach to web design strategy that will produce attractive, flexible, maintainable, accessible and controllable content. Dan uses XHTML and CSS for his discussions and has the goal of reducing bloated code down to the bare essentials to get the job done. He starts each chapter with an example site that is not bulletproof then does a makeover to see how it should be done.

Chapter 1 is about using text in such a way to maximize flexibility. Using CSS to control all aspects of the text he shows how to make the text easy to maintain, accessible to multiple types of devices and screens, and allow the user to control the text size (to increase readability) and weight of the page (by not loading images.)

Starting with an absolute font size using keyword units such as “small” applied to the tag all other font sizing is then made a relative size to it using % changes. He provides work arounds for IE5’s lack of CSS compatibility in some situations and offers cautions for when using relative % sizes within multi-layered nesting of tags. Nested tags that have % sizes are additive and can result in unpredictable results in some cases.

ColdSpring

bruce — Fri, 17 Nov 2006 16:37:16 +0000

Barney Boisvert presented on ColdSpring (or “CS” henceforth) at last night’s PDXCFUG meeting. This open source framework technology has been around since 2002 as a framework for Java known as Spring. It has since been adapted to work with ColdFusion within the past year. It is not a “port” but borrows the XML syntax from it.

CS is basically a framework for CF Components or CFCs. It focuses on the management of CFC configuration and dependencies so you don’t have to as much. It uses a pattern called “inversion-of-control” or IoC to “wire” your CFCs together. IoC is another name for Dependency Injection or DI and accurately describes what CS does. A dependency is when one piece of code depends on another to get it’s job done. You have some functionality that is needed by several other pieces of code in your application. You create a CFC to implement that functionality. Each time you instantiate the use of that CFC elsewhere in your code, a coupling takes place. The two ends of this “coupling” are known as “collaborators”. As your application grows the management of keeping things together or coupled becomes harder. Each of your components using the CFC needs to know how to “use” the CFC, how to create and configure it. That’s where CS comes in. CS allows you to remove the sprinkling of code required to couple to the CFC and manages it for you. Collaborators don’t need to know how to create or find each other but are simply “given” them by CS.

Another way to think of CS is as a generic CFC factory and registry. Registries are object warehouses or a collection of references. Factories are built on top of registries and act as an object source. It encapsulates instantiation of objects and manages singletons (one instantiated bean in memory that is shared by all.) Think of DI as a “super factory registry” (Barney’s term) or technically a Bean Factory that is XML based and encapsulates the dependency and initialization of beans. Beans all load into memory at the startup of an app so the load time takes longer but then benefits from the fast access during use. The wiring for resolving dependencies is done with either “constructor” objects or “setters” objects.

In addition, CS introduces the first Aspect-Oriented-Programming (AOP) framework for CFCs. This framework manages “cross-cutting concerns” or tasks that permeate the application but are not the responsibility of any one object. Examples include application security, transactions and logging. AOP provides a way to deal with this and allows massive code reuse. Using AOP terms, AOP deals with Aspects (concerns) and offers Advice (a way to deal with the concerns).

The question was raised about CS framework and other frameworks such as Fusebox, Mach-II, and Model-Glue. The later are primarily frameworks for managing the front-end of applications or web applications in general, whereas CS is a framework for the business logic or backend functionality. THink of CS as a business controller and FB as a frontend controller.

In conclusion, CS is described as complicated to grasp and understand but once you do, the time savings and code reuse it allows will be well worth it. It offers a powerful way to manage the CFCs in your applications more easily.

Performancing FF Plugin Editor

bruce — Wed, 25 Oct 2006 04:16:44 +0000

Downloaded and installed Firefox 2.0 web browser for the Mac. This upgrade is great so far, nicer tabs, close tab x button on each tab instead of off to the far right, and other features yet to be discovered. I also found add-in enhancements such as FireFTP, an ftp client built into the web browser window. But another plugin is a Performancing editor for blog postings. I use WordPress for my blog needs and this editor is compatible with it and other popular blogging products. It is a full featured web editor and lets you create accounts for each blog complete with login requirements. Then you can click to select which blog you want to post to and type what you want. Click the Publish button when done and it’s posted on your blog. Very slick and well done. Check it out at: https://addons.mozilla.org

Avoiding Broken URIs

bruce — Wed, 09 Aug 2006 18:35:58 +0000

Found some articles that discuss the problem of broken URIs or links. Everyone experiences this while suring the internet and it’s discouraging to encounter and can even cause you to give up your goal. The damage to the site’s reputation is non-trivial. As the quantity of broken links encountered on a site go up, the confidence of the user in that company or site goes down.

So how do you prevent or minimize this problem on your website? I found an article on the w3.org web site that addresses this with some useful guidelines. The article “Cool URIs don’t change” by Tim Berners-Lee first covers the excuses people give for changing their URIs within their website. Some are good and some lame. If interested in them click on the article link and read them, but I wanted to summarize the suggestions for preventing the problem in the first place. I thought they were good.

Tim believes it is the duty of the webmaster to allocate URIs that will be around for many many years. People embed reference links in their websites, in documents, in their browser bookmark lists, and possibly in an email or letter to a friend. It requires careful planning and commitment to correct so that in a year or two when a redesign comes along or a technology changes, the URIs don’t break.

First putting the creation date of the document somewhere into the URI path is a good idea. This is a constant and won’t ever change.

What to leave out of the path:

Authors name - it changes when someone else is assigned ownership, people quit, orgs change.
Subject - looks good but frequently ends up changing sooner or later
Status - this changes too, “drafts” become “final”, “new” becomes “old”, etc.
Access - team access may change to public access, members only becomes archived, etc.
File name extension - .html may become .cfm or .php, .cgi or .pl may become .txt or .html
Software mechanisms - “cgi”, “exec”, etc suggests you won’t ever change the technology used to display the documents
Disk name - don’t include it in the URI…it will change at some point in time

An example of a good solid URI: http://www.w3.org/1998/12/01/chairs
a report of the minutes from a W3C chair people meeting.

What about topics and classifications by subject? This is not recommended either. Classifications also tend to change, even spelling of words representing categories can change such as a URI with “MarkUp” in it may be changed to “Markup” or “HTML” and the link breaks. A particular organization method may look excellent and perfect at the time but later doesn’t fit the ever changing environment. Everyone can interpret an organization differently, so as people in positions change, the view of an organization scheme changes. Adding a date such as a year into the URI can help protect categories because it tends to freeze a snapshot of things at that point in time while changes in the future will use a new URI with a date in it.

It is also a dangerous idea to use special domain names in the URI, such as for a server of documents that contains a subdoman of cgi.domain.com or secure.domain.com, etc. These too may change at some point. It is better to use the main domain name and then use redirects and proxying to route the path to separate servers.

Tim also suggests dropping the use of file name extensions completely. If your web server is Apache or IIS you have the option of doing what is call “Content Negotiation”. This allows for the server to be told how to deal with URIs that have no extention. For example, if an image resource is referenced as /pictures/tiger then through content negotiation the web server will find not only the tiger.jpg or tiger.gif but will select the preferred format if more than one exists in the same directory.

I found good documentation on how to configure Apache to do content negotiation if you want to use it. Check out “Content Negotiation” in the Apache online documentation.

PHP Output Buffering

bruce — Tue, 08 Aug 2006 22:48:33 +0000

Chapter 11 in “PHP In A Nutshell” book by Paul Hudson described what output buffering is and how to use it and why.

By default PHP will transfer display information to the client’s web browser as soon as it’s ready to be sent. However the display does not occur until the end of the script has been reached. But this can be slow as it waits for all the bits of data to be computed and restricts you on the order that it’s displayed. With output buffering you can gather chunks or all of the display output and rearrange the chunks if needed or negate displaying them at all based on conditions you choose such as error conditions. It also lets you compress the output before sending it to the client and reduces the amount of data needing to be transferred, however the savings in bandwidth may be negated by the extra CPU time needed to do the compression.

To buffer output, you call the ob_start() function before the output is sent. When the output in this chunk is complete, then you can either call ob_end_flush() which dumps it immediately to the client’s web browser or call ob_end_clean() which clears the buffer. If you wish to hang on to the buffer contents you can either load it into a string var (explained below) before clearing the buffer or you can open a new buffer with a second ob_start() function call instead of the ob_end_clean. This effectively puts the first buffer contents on hold while a new nested buffer collects the output generated from that point on. Calling the ob_end_flush after some output is generated will flush the output in this nested second buffer into the first output buffer. Or again, calling ob_end_clean would clear the second buffer instead, returning further output collects going into the first output buffer again.

Two other functions, ob_flush and ob_clean do the same things as the ob_end_flush and ob_end_clean functions respectively except the output buffer isn’t closed. To read the current output buffer content, use the function ob_get_contents() which returns the buffer as a string. Once the buffer contents are in a string var then you can use it later for display or for writing to a file or based on error or other conditions, decide what to do with it.

Using these functions carefully can result in control over what is output and in what order. One possible use of the output buffering would be to help separate the PHP code used to process a form submission that validates the form input before the display template is generated, allowing the error messages to be collected prior to the page html code is generated.

Another handy function to use is the flush() function which displays the output so far immediately. This is primarily useful when the end of the script has not been reached and you want to display what has been generated so far in the buffer. It can also be useful when the output buffering is not being used but the output content being generated is taking a long time to crunch through.

To compress the output buffer contents, pass the parameter ob_gzhandler to ob_start(). This essentially zips the information before it is sent. The last section of the chapter discusses url rewriting, which allows for adding url parameters on all url references and hidden form elements within the output buffer. This is done using the functions output_add_rewrite_var() function. If you later change your mind and want to undo the added URL and form element additions, then call the function output_reset_rewrite_vars() which removes them.

PHP Cookies and Sessions

bruce — Tue, 08 Aug 2006 21:51:50 +0000

Going back to Chapter 10 in Paul Hudson’s book “PHP In a Nutshell” he covers cookies and sessions. Cookies are tiny little chunks of information passed from the server to the client’s web browser and stored on the client’s computer, which the web browser manages. If you prefer to prevent the user from possibly manipulating the information in the cookies, some prefer storing the information on the server side using session variables. A small cookie is used to store a reference session id for each client which is read each page call to lookup that client’s session id value, then associated with some server side variables store in memory.

PHP uses the function setcookie() to have the server pass the information to the client’s browser with the command to save it in a cookie. This function allows you to specify the name of the cookie, the value, and expiration date/time. Additionally you can limit the readability of the cookie to a particular directory within the domain website or to just a particular sub-domain of the domain. You can also specify if only the secure https server can read this cookie or both http and https servers have access to it.

To use session variables you must first call the function “session_start()” which checks for the client-side cookie containing the session id. If none is found then one is created. Since the returned data from this function can only be transferred within the http header, it is therefore important to make this call before any web page body code is read.

Session variables can be written on one page and then read from aother. As long as the session id cookie has not expired or been deleted, that session is “alive”. It is possible to remove a set of session data and ending the session. All session vars can be read using the superglobal array $_SESSION.

The last half of the chapter goes over how session handling is done in PHP using flat files referenced using the unique session id handed out when session_start was called. It is possible to do the session handling yourself and in a more secure/safe way, such as using a database to manage the session management. Paul discusses how this is done and what functions need to be written to do this.