Just in Time for Christmas: Vista in the Crosshairs

Or, Give your computer the bird.

Computers are frustrating. Creating documents, finding files, sharing information — why do everyday things still seem so tedious and counterintuitive?

Dave Kushner interviews Blake Ross and gets a preview of his new Parakey venture in the November issue of IEEE Spectrum. Ross, a 20-yr old wunderkind and one of the driving forces behind the Firefox browser, has teamed with Joe Hewitt of Firefox and Firebug fame to create an absolutely disruptive new approach to computing. Quoting from Kushner’s article:

Just as with Firefox, Ross began this project by asking himself one simple question: What's bad about today's software? The answer . . . resided in the gap between the desktop and the Web. . . . The problem, according to Ross, is there's no simple, cohesive tool to help people store and share their creations online. Currently, the steps involved depend on the medium. If you want to upload photos, for example, you have to dump your images into one folder, then transfer them to an image-sharing site such as Flickr. The process for moving videos to YouTube or a similar site is completely different. If you want to make a personal Web page within an online community, you have to join a social network, say, MySpace or Friendster. If you intend to rant about politics or movies, you launch a blog and link up to it from your other pages. The mess of the Web, in other words, leaves you trapped in one big tangle of actions, service providers, and applications. Ross's answer is . . . Parakey, "a Web operating system that can do everything an OS can do." Translation: it makes it really easy to store your stuff and share it with the world. Most or all of Parakey will be open source, under a license similar to Firefox's.

Thus, Parakey aims to bridge the divide between desktop operating systems and the Internet, using the browser as the common user interface. Parakey will give users the ability to easily host their own Web sites via their desktop. Even though Parakey works within the browser (all leading ones are to be supported), it actually runs on the local computer. This enables developers to do many things not allowable in a traditional Web site. By the use of easily assigned “keys”, the desktop owner can also easily and simply post or allow access to content of their choosing — from documents to photos to files — to become “public” to the distribution lists associated with these keys. Remote users get issued cookies so that their access to the local resources is seamless and without friction.

Similar to the models of the Firefox plugin or Web services, the basic Parakey platform can be easily extended. Ross and Hewitt have created a programming language, JUL (for ‘Just another User interface Language’), likely similar to the Mozilla XUL, for developers to write these components and extensions. Though the launch date for Parakey is being kept under wraps, all signals point to before January. The pre-launch company site allows interested parties to enter their email address to receive formal notification of the launch.

It is rather amazing that this article came out on the same day, yesterday, as John Milan’s blog post on Elephants and Evolution – How the Landscape is Changing for Google, Microsoft, Mozilla and Adobe on Richard McManus’s Read/Write Web blog. In that post, Milan posits Mozilla as another one of the gorillas (elephants) in the room and Adobe’s Apollo project as another “under the radar” approach to the desktop/Internet browser convergence.

All of this seems rather ironic as the world (Redmond) awaits the release of the long-delayed Windows update, Vista. Even the mighty do indeed live in interesting times.

Matt Asay, of OSBC and Alfresco, makes a very telling point in a recent post: One power of open source (if done right) is its suitability to interoperability and extensibility. As Matt states:

. . . let me give him/you an idea of what we’re already doing in this space. It’s not a question of what we might do, but what we’re already doing. You can get Alfresco integrated with Asterisk (VoiceRD from Novacoast) and SugarCRM (CRM) today. (And since our 1.4 Business Process Management release, we already have BPM in spades.)

Now extend this. Add some JasperSoft or Pentaho for Business Intelligence (perhaps reporting capabilities). Some DimDim for web conferencing. Some Zimbra or Scalix for email/collaboration. Want to scale this out on a grid? Get yourself some 3Tera. Etc. The great thing about all of this is that we don’t have to do all of it ourselves. In many instances, enterprises are already extending Alfresco (or these other projects) to meet these and other needs. Hence, when a large pharmaceutical/medical devices company wanted wiki functionality in Alfresco, it didn’t ask us. It just built it in.

One could certainly make the argument that first-generation open source like Linux was adopted for cost, risk and code-access purposes, and that second-generation open source like JBoss or Red Hat was adopted because of completeness and support across a broader portion of the stack. But I think what we are now seeing in third-generation open source efforts like Alfresco or LogicBlaze is the enterprise-scale integration and interoperability of components.

Open source combined with open standards avoid vendor lock-in and points the way to a very, very different application and deployment paradigm: identifying, evaluating and glueing, rather than baking the cake each time from scratch.

I have been assembling for some time a listing of semantic Web-related software applications and tools. My first partial listing had about 50 sources. I recently noted the W3C’s semantic Web wiki listing of about 70 sources. I then came across the EU’s AKT (Advanced Knowledge Technologies) project, which also has about 75 tools compiled. Protégé also has a fairly long list of plugins, but not unfortunately well organized. Complicating matters still was the listing of natural language processing tools listed at the Natural Language Software Registy, another fantastic resource particularly in the annotation and information extraction arena.

Semantic Web tool sets span from comprehensive engineering environments to specific converters and editors and the like. The entire workflow extends from getting the initial content, annotating or tagging it according to existing or built ontologies, reconciling heterogeneities, and then storing and managing the RDF or OWL with subsequent querying and inferencing.

There are certainly more tools extant, and I made some choices to exclude some marginal tools (Sourceforge, for example, has more than 200 semantic Web-related projects, but the vast majority appear moribund with no actual software to download).

Thus, listed below, are today’s current, most comprehensive list of 175 semantic Web software tools and applications. I am now further characterizing these offline as to open source v. proprietary and categorizing according to SW-related workflow. I may later post those expansions.

I also welcome tool suggestions. I think the ESW tools listing is the best place ongoing for such a compilation, but so far I am not liking what I am seeing in vendors using hype to characterize their tools versus more dispassionate descriptions by practitioners.

John Newton (co-founder formerly of Documentum, now of Alfresco) puts a telling marker on the table in his recent post on the Commoditization of ECM. Though noting the term "enterprise content management" did not even exist prior to 1998, he goes on to observe that expansion of the definition of what was appropriate in ECM and the consolidation of the leading players occurred rapidly. He concludes that this process has commoditized the market, with competitive differentiation now based on market size rather than functionality. The platforms from the leading IBM, Microsoft and EMC-Documentum vendors all can manage documents, Web content, images, forms and records via basic library services, metadata management, search and retrieval, workflow, portal integration, and development kits.

If such consolidation and standardization of functionality were Newton’s only point one could say, “ho, hum,” such has been true in all major enterprise software markets.

But, in my reading, he goes on to make two more important and fundamental points, both of which existing enterprise software vendors ignore at their peril.

Poor Foundations and Poor Performance

Newton notes that ECM applications are never bought based on the nature of their repositories, but an inefficient repository can result in the rejection of the system. He also acknowledges that ECM installations are costly to set up and maintain, difficult to use, poorly performing and lack essential automation (such as classification). (Kind of sounds like most enterprise software initiatives, doesn’t it?)

Indeed, I have repeatedly documented these gaps for virtually all large-scale document-centric or federated applications. The root cause — besides rampant poor interface designs — has been in my opinion poorly suited data management foundations. Relational or IR-based systems both perform poorly for different reasons in managing semi-structured data. This problem will not be solved by open source per se (see below), though there are some interesting options emerging from open source that may point the way to new alternatives, as well as incipient designs from BrightPlanet and others.

The Proprietary Killers of Open Standards and Open Source

Service-oriented architectures (SOA), the various Web services standards (WS**), the certain JSRs (170 and 283 in documents, but also 168 and others), plus all of the various XML and semantic derivatives are moving rapidly with the very real prospect of “pluggability” and the substitution of various packages, components and applications across the entire enterprise stack.

In quoting Newton’s case at Alfresco, by aggregating these existing open source components they were able to get their ECM product ready in less than one year:

• Spring – A framework that provides the wiring of the repository and the tools to extend capabilities without rebuilding the repository (Aspect-Oriented Programming)
• Hibernate – An object-relational mapping tool that stores content metadata in database and handles all the idiosyncrasies of each SQL dialect
• Lucene – An internet-scale full-text and general purpose information retrieval engine that supports federated search, taxonomic, XML and full-text search
• EHCache – Distributed intelligent caching of content and metadata in a loosely coupled environment
• jBPM – A full featured enterprise production workflow and business process engine that includes BPEL4WS support
• Chiba – A complete Xforms interface that can be used for the configuration and management of the repository
• Open Office – Provides a server-based and Linux-compatible transformation of MS Office based content
• ImageMagic – Supports transformation and watermarking of images.

Moreover, the combination of these components led to an inherent architecture including pluggable modules, rules and templating engines, workflow and business process management, security, and other enterprise-level capabilities. In prior times, I estimate no proprietary-based vendor could have accomplished this for ten times or more the effort.

Similar Trends and Challenges in the Entire Enterprise Space

Newton is obviously well placed to comment on these trends within ECM. But similar trends can be seen in every major enterprise software space. For virtually every component one can imagine, there is a very capable open source offering. Many of the newer open source ventures are indeed centered around aggregating and integrating various open source components followed by either dual-source licensing or support services as the basis of their business models. At its most extreme, this trend has expanded to the whole process of enterprise application integration (EAI) itself through offerings such as LogicBlaze FUSE with its SOA-oriented standards and open source components. Initiatives such as SCA (service component architecture) will continue to fuel this trend.

So, enterprise software vendors, listen to your wake up call. It is as if gold dubloons, pearls and jewels are laying all of the floor. If you and your developers don’t take the time to bend over and pick them up, someone else will. As Joel Mokyr has compellingly researched, the innovation of systems or how to integrate pieces can be every bit as important as the ‘Aha!’ discovery. Open source is now giving a whole new breed of bakers new ingredients for baking the cake.

Author's Note: There is a zipped plugin, code and documentation that supports the information in this post, which will allow you to extend the functionality of your TinyMCE rich text editor in WordPress; for immediate instructions see the end of the post below.
Click here to download the zipped file (101 KB)

My most recent post was about the smooth upgrade to WordPress v. 2.0.4 for my blog software and noted my popular Comprehensive Guide to a Professional Blog Site recounting my own experiences setting up, configuring and maintaining my own blog site. A key aspect of that earlier Guide dealt with (what I perceived to be) an oversight in older versions of WordPress that lacked a bundled WYSIWYG editor. For my own site and installation, I had chosen the Xinha editor, and had devoted a number of entries in the Guide to its configuration and use.

However, as of WordPress version 2x, the developers have now chosen to bundle the proven Javascript rich text editor, TinyMCE, as part of the standard distribution package. Since I had come to rue some of the aspects of Xinha in my earlier implementation (namely, bad HTML for carriage returns and VERY slow times when publishing a post), I decided to give TinyMCE a go as my new replacement editor.

(Actually, this was not such a major shift since we had adopted a sibling TinyMCE application, the Joomla Content Editor (JCE), for the Joomla-based BrightPlanet corporate Web site.)

As implemented, the TinyMCE editor in WordPress is configured more akin to the prior QuickTags feature set, with the few available editing functions being bold, underline, bullets, text alignment, and so forth. Here is a screen shot from my WordPress administration center with TinyMCE as delivered with WordPress v. 2.0.4:

The only problem is that I have become used to editing support for items such as tables, image manipulation, special characters, font types, and so forth. While I (generally) edit and clean up the HTML before final posting, I very much enjoy the productivity benefits of a more full-featured WYSIWYG editor. So, the rhetorical question to myself was: If I’m going to use TinyMCE, how can I extend its functionality?

The Investigations Begin

Having been familiar with other TinyMCE instantiations, I began my investigations with the (as it turns out naà ¯ve) assumption that upgrading to a full featured TinyMCE would be a snap. Boy, was I wrong.

I first began with the TinyMCE Web site itself checking out the standard distribution package. Like many open source sites, I found the online documentation for TinyMCE to be fragmented, incomplete and hard to navigate. I looked under the ‘Plugins’ tab and found it was documentation for developers in creating a new plugin. My first lead came from the online manual (which can also be downladed for local browsing) and its reference to installation options, specifically these options at the bottom of that page:

• Example 00 – Simple Theme
• Example 01 – Advanced Theme
• Example 02 – Advanced Theme Full
• Example 03 – Advanced Theme Simplified

Bingo! Clearly, TinyMCE had the advanced features I was seeking and they were packaged as part of the direct TinyMCE distribution to boot! Now I assumed my only needed step was to find how to “turn on” these features in my WordPress installation.

What Was Learned
This line of thinking led me to an unfortunate waste of time in Web search and poking through the forums at both the TinyMCE and WordPress sites. It became clear that the TinyMCE integration in WordPress was both highly tailored and limited to just the simple functionality (Example 00 above). I saw references by others to the “wisdom” of the WordPress developers to making this choice and therefore reducing the overall size of the WordPress download, but I don’t see it that way. It seems rather arbitrary and taking available choices from the user by unilaterally “whittling down” a more fully featured option from Moxiecode. Oh, well.

One dead end among many I pursued was instructions from the TinyMCE staff on integrating Moxiecode’s commercial plugins. That reference — http://tinymce.moxiecode.com/downloads/integration/ — got me way too into specific WordPress code that I was also unable to modify for my specific plugin purposes (though perhaps more capable programmers could have seen a clear path). I also found many requests but little guidance from the WordPress forums.

The first breakthough occurred on the TinyMCE Wishlist postings on the WordPress forum, which led me to the Advanced WYSIWYG plugin by Assaf Arkin of Labnotes. Part of the problem in finding this in the first place was that the actual plugin file name was misspelled as “advacned-wysiwyg”. So, I followed the instructions for the plugin and, voilÃ, it didn’t work!

Grr! More investigation indicated that the likely problem resided in new version 2x plugins for TinyMCE as NOT working with the Advanced WYSIWYG plugin. As Paul Finch reported on the Labnotes site, reverting back to earlier advanced plugins for TinyMCE in versions 1.45 and earlier, which could be found on the Sourceforge download site, solved the problem.

As indeed it does, as this updated editor on my blog administration panel shows:

These “standard” advanced plugins for TinyMCE provide possible functionality beyond the simple installation (marked with an asterisk [*]) (also, ones I could not get to work — but I did not test all of them! — are shown with double asterisks [**]) for:

Default buttons available in the advanced theme:

* bold
italic
* underline
* strikethrough
* justifyleft
* justifycenter
* justifyright
* justifyfull
* bullist
* numlist
outdent
* indent
cut
copy
paste
* undo
* redo
* link
* unlink
* image
cleanup
help
* code
hr
removeformat
formatselect
fontselect
fontsizeselect
styleselect
sub
sup
forecolor
backcolor
charmap
visualaid
anchor
newdocument
separator

Plugins with the button name same as plugin name:

save
emotions
flash
iespell
preview
print
zoom
fullscreen
advhr
fullpage
spellchecker

Plugins with custom buttons:

advlink (will override the “link” button)

advimage (will override the “image” button)

paste

• pastetext
• pasteword
• selectall

** searchreplace

• search
• replace

insertdatetime

• insertdate
• inserttime

table

• tablecontrols
• table
• row_props
• cell_props
• delete_col
• delete_row
• col_after
• col_before
• row_after
• row_before
• row_after
• row_before
• split_cells
• merge_cells

directionality

• ltr
• rtl

layer

• moveforward
• movebackward
• absolute
• insertlayer

** style

• styleprops

Early Use Observations

With one major exception — and it is MAJOR! — I have generally been pleased with the new TinyMCE editor in its full functionality version. I have been working with it for nearly a week and have completed four or five published posts. The writing of posts is now much quicker. There are no longer problems with line breaks and paragraph formatting. For most functionality, the editor just feels more “solid” than my previous Xinha editor. For all of that, I am very thankful.

The major issue I have encountered is with long posts (such as this one), particularly when I am toggling between the code (HTML) view and WYSIWYG view. Without warning, I will suddenly lose entire portions of text at the bottom of the post. This appears to be either strictly a TinyMCE issue or perhaps an issue related to my Firefox browser that others have noted on the WordPress forum.

Best practices, as I have reported on elsewhere and as part of my Guide, generally suggest drafting long posts external to WordPress anyway, though the loss of any work is distressing. I will monitor this “long posting” issue carefully, and until I see a resolution I will likely save to the clipboard or take other steps to prevent future losses.

Specific Upgrade Instructions

So, because I have generally been pleased with these extensions, I thought I would package and write them up for others to use, saving you the fits and starts I went through. The download at the top of this post includes the instructions and all files noted below. The instructions are included as the readme.txt file in the package. I also chose to make some minor updates to plugin operation (better sizing of popups, for example) and also corrected the spelling error in the file name and allowed for multi-line bullets for the extended TinyMCE in the Advanced WYSIWYW plugin. All of these changes, plus the vetted TinyMCE ver. 1.45 advanced plugins, are included in the distribution. Please note this information is being provided “as is”; you can also only do this if you have direct file access to your WordPress installation.

1. Download the enclosed zip file and unzip it to a clean subdirectory; these instructions are repeated in the enclosed readme.txt file.

2. If you don’t like the button order shown in the image above, you may remove buttons or change ordering or add or remove separator bars by editing the advanced-wysiwyg.php file:

< ?php
/*
Plugin Name: Advanced WYSIWYG Editor
Plugin URI: http://www.labnotes.org/
Description: Adds more styling options to the WYSIWYG post editor, updated for multi-line buttons.
Version: 0.3
Author: Assaf Arkin
Author URI: http://labnotes.org/
License: Creative Commons Attribution-ShareAlike
Tags: wordpress tinymce
*/

if (isset($wp_version)) {
add_filter(“mce_plugins”, “extended_editor_mce_plugins”, 0);
add_filter(“mce_buttons”, “extended_editor_mce_buttons”, 0);
add_filter(“mce_buttons_2″, “extended_editor_mce_buttons_2″, 0);
add_filter(“mce_buttons_3″, “extended_editor_mce_buttons_3″, 0);
}


function extended_editor_mce_plugins($plugins) {
array_push($plugins, “table”, “fullscreen”, “searchreplace”, “advhr”, “advimage”);
return $plugins;
}


function extended_editor_mce_buttons($buttons) {
return array(
“undo”, “redo”, “separator”, “cut”, “copy”, “paste”, “separator”, “bold”, “italic”, “underline”, “strikethrough”, “separator”,
“bullist”, “numlist”, “separator”, “indent”, “outdent”, “separator”,
“justifyleft”, “justifycenter”, “justifyright”, “justifyfull”, “separator”,
“sub”, “sup”, “charmap”, “hr”, “advhr”,”separator”, “link”, “unlink”, “anchor”, “separator”,
“code”, “cleanup”, “separator”, “search”, “replace”, “separator”, “wphelp”);
}

function extended_editor_mce_buttons_2($buttons) {
// the second toolbar line
return array(
“formatselect”, “fontselect”, “fontsizeselect”, “styleselect”, “separator”, “forecolor”, “backcolor”, “separator”,”removeformat”);
}

function extended_editor_mce_buttons_3($buttons) {
// These are the buttons for third toolbar line
return array(
“image”, “separator”, “tablecontrols”, “separator”, “fullscreen”, “wordpress”);
}
?>

3. Copy the resulting advanced-wysiwyg.php file into your standard WordPress plugins directory (wp-content\plugins)

4. Copy all files from the extracted plugins subdirectory to the TinyMCE plugins subdirectory in your WordPress directory (wp-includes\js\tinymce\plugins)

5. Under ‘Plugins’ in your WordPress administrative center, ‘activate’ the Advanced WYSIWYG Editor plugin

6. Now, when you write or manage posts or pages you will have the extended TinyMCE functionality available

7. Enjoy!