Category: Enterprise 2.0

Extending Crafter Engine with Java backed functionality

Posted by on October 06, 2012

Crafter Engine is the high-performance website / web app delivery engine for Crafter Rivet Web Experience Management. Out of the box Crafter Engine ships with support for many of the types of engaging functionality you have come to expect from a WCM/WEM platform.  However, there are times when we want to add additional capabilities to integrate with internal and 3rd party systems to meet specific business objectives.  In this article we’ll demonstrate how you can create Java backed plug-ins for Crafter Engine.

To illustrate the integration process we’ll integrate a simple RSS reader based on the ROME RSS processing library
You can download this example (and others) at the following SVN location: https://svn.rivetlogic.com/repos/crafter-community/ext/engine

To begin let’s start with some background on Crafter Rivet, Crafter Engine and how a plug-in is organized structurally:

Crafter Rivet

Crafter Rivet is web experience management solution based on the Alfresco Content Management platform with a de-coupled architecture.  This means that the authoring environment and the production delivery environment are separate infrastructure integrated by workflow and deployment from authoring to delivery.  Crafter Rivet components power some of the internet’s largest websites.  A decouple architecture makes things easier to support, more flexible and very scalable.

Crafter Engine

Crafter Engine owes its performance characteristics to its simplicity.  Content is stored on disk and is served from memory.  Dynamic support is backed by Apache Solr. At the heart of Crafter Engine is Spring MVC, a simple, high performance application framework based on one of the world’s most popular technologies: Spring framework.

What is a Crafter Engine Plug-in

A Crafter Plug-in is a mechanism for extending the core capabilities of Crafter Engine, the delivery component of Crafter Rivet. Plug-ins allow you to add additional services and make them available to your template / presentation layer.

An example plug-in as we suggested above might be an XML reader which would function as specified below:

  • The plugin would expose a in-process Java based service like Feed RssReaderService.getFeed(String url)
  • Your your presentation templates would then simply call <#assign feedItems = RssReaderService.getFeed(“blogs.rivetlogic.com”) />

Anatomy of a Crafter Engine Plug-in

You will note from the diagram above that plug-ins are simple JAR files that contain both Java code, configuration and an Spring bean factory XML file that loads and registers the services with Crafter Engine.

Loading the plug-in

1. When the container loads the Crafter Engine WAR the shared classes lib folder is included in the class path.

2. When the Crafter Engine WAR starts up it will scan the class path for its own spring files and any available plug-ins. At this time the services described in the Spring bean XML file with in your plug-in will be loaded. Your service interfaces are now available in the presentation layer.

Interacting with your service

A. The user makes a request for a given URL

B. Crafter Engine will load all of the content descriptors from disk for the page and components needed to render the specific URL. Once the descriptors are loaded the templates for the page and components will loaded from disk.

C. The templates may now call your service interfaces to render from and interact with your back-end code. Your Java backed service may then do whatever it was intended to do, returning the results to the template for processing. Once complete, the responses are then returned to the user in the form of a rendered web page.

A simple Example

Now that we have a bit of background, let’s get down to the nuts and bolts of the matter and build, install and configure our RSS reader integration.

The Java Service

/**
 * Reads a RSS or Atom feed from a specified URL and returns a data structure that can be accessed from a template.
 */
public class RssReaderService {

    public SyndFeed getFeed(String url) throws IOException, FeedException {
        SyndFeedInput input = new SyndFeedInput();
        XmlReader reader = new XmlReader(new URL(url));

        try {
            return input.build(reader);
        } finally {
            try {
                reader.close();
            } catch (IOException err) {
                // handle error
            }
        }
    }
}

The Configuration

/crafter/engine/extension/services-context.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <bean id="rssReaderService" class="org.rivetlogic.crafter.engine.rss.RssReaderService" />
</beans>

Packaging and Install

The compiled class and spring configuration file must be found in the class path.  To facilitate this we build these objects and their dependencies in to a single JAR file.  You can find the build process for these at the SVN location above.  Place the JAR file that is produced by the build process in to your shared class path for example: /TOMCAT-HOME/shared/lib and restart the application.

Now that you have restarted the application your service is available to your presentation layer.  This means that in any template you can now add the following:

<#assign feedItems = RssReaderService.getFeed(“blogs.rivetlogic.com”) />

Using the Plug-in:

Web Ninja: Create a RSS Feed Component for Authors

Create a new content type as a component:

Create a template for the RSS Widget by clicking on the type canvas and editing the template property:

Author: create and configure a RSS Component

Modify the component properties through the content type form:

And insert the widget in to a web page:

Save and close and the configured component is now showing on your web page!

Web CMS on The Alfresco Core Repository (Part 2 of 2)

Posted by on April 10, 2012

In yesterday’s post we covered the fact that Alfresco stopped selling the AVM based WCM solution to new customers.  Existing customers using the AVM based approach will continue to receive support until the AVM reaches end of life status.  New customers looking to Alfresco for WCM/WEM capabilities who read this will naturally wonder what is the approach to WCM on Alfresco.  Existing customers will want to know how to migrate off the AVM and in to Alfresco’s core repository.

As we have seen in yesterday’s post, the core repository has had the benefit of continuous innovation through which it has grown as a platform now capable of supporting use cases critical to WCM/WEM with key features like remote file deployments and form based content capture.  Along with features clearly directed at the WCM use cases, the core repository is host to an amazing array of features and capabilities that make it ideal for all manner of enterprise management, WCM/WEM included.

At Rivet Logic we have made a significant investment in a web content and experience management extension to Alfresco that we call Crafter Rivet. Crafter Rivet is a 100% open source,  full featured application that powers 100s of websites and has over 40 man years of development effort invested in it. Initially Crafter Rivet’s authoring and management capability was based on the AVM. When Alfresco made the decision to direct the full force of its innovation on the core repository we knew it was time to covert. Just released, Crafter Rivet 2.0 is 100% based on the core repository, Solr search and Actviti workflow for Alfresco 4 CE and EE.  Making the switch from the AVM to the core repository required a deep examination of our use cases and the features we would have on hand within the core repository.

Now that we have a background understanding of both the AVM and core repository features we discussed yesterday it is time to look at the use cases that the AVM was designed to address.  We will discuss the use case and how these gaps were addressed by Crafter Rivet.  Let’s get started!

Use Case: Sandboxing
As described in yesterday’s blog, sandboxing is a feature but there are use cases that drive this feature. In a Web CMS context we have times when we need to modify templates, CSS and other assets that have far reaching effects on our sites. There are three common use cases that point to sandboxing:

  • Development:  As a developer I want to work with a template, a CSS file, a JavaScript library, etc. without worrying that the bugs I will inevitably create will interfere with the rest of the teams ability to produce, manage, preview and publish content.
  • Timing: On websites of significant size and complexity, there are often times when projects are created to update the look and feel of the site.  These projects with future delivery dates need to be able to take place without interfering with daily publishing.  Further, it’s important that the project be able keep up with on-going updates to reduce the headache of last minute merges.
  • Playground:  Sometimes we just want to play.  Sandboxes allow us to enable team members to innovate and play around without fear of impacting the live website.

It’s clear that the ability to sandbox (or branch/merge) your website code base can be pretty handy. In my mind there are several key questions:

  • Is the support for this use case a “must have” for my specific environment?  How often do I run in to the use cases above?
  • What granularity of sandboxing do I need?

Many popular Web content management systems do not natively support sandboxing. In a lot of cases the need for the branch merge capability is handled through the development and deployment process. In general I think it safe to say this feature is a rather strong “nice to have” unless you have an site with look and feel components which are literally being constantly updated and where the traditional development process would add too much time to the effort.

When you do need sandboxes the next question is granularity and how sandboxes are used. The AVM UI dictates sandboxes for each user. In my experience accumulated over many Alfresco WCM engagements; is that this was too fined grained for the needs of most engagements.  Most users want to work directly in context with other users.  They need basic locking on individual assets to keep work safe during their edits but they don’t require an entirely separate and parallel universe.  The ability to create a sandbox ad-hoc for a specific purpose maps more directly to the needs we see on the ground. In other words, a sandbox is too granular but a sandbox for a project to update the look and feel of the entire site where users could work together would more aptly address the kind of needs we see.

Crafter Rivet starts with the first finding, that sandboxing is not a “must have” feature and that in-fact when it is applied it should be done so to facilitate specific projects and specific ad-hoc needs. If you look at the way we have structured our content in the core repository you will see we have left room to support one or more draft copies of the site.  In v2.0 we do not support layering in the default configuration; however, Crafter Engine, our content delivery and preview tier, is able to sit over top of multiple hierarchical stores and present them as one store much in the same way the AVM did.

Use Case: History and Reversion in a Web CMS Context
As a user, when I want to preview a version of a specific asset, let’s say a page,  I want to see the page as it was on that day. That means I want to see exactly the same components and assets (images, CSS, js etc) as they were on that given day.  This is a real challenge in the core repository because there is no native support linking assets together under a common version; each asset is individually versioned and the links between objects (associations) do not capture version.

Now to be honest, I have simplified the problem a bit to make a point.  I said that pages, for example, are compound assets and that you are always interested in seeing their dependencies at a given point in time.  This is often the case when we’re talking about images and components that are specific to the page but it’s not really the case when we’re talking about shared assets like templates, CSS, JavaScript, and shared components and shared collateral.  Think for a moment about why users want to look at and ultimately revert to previous versions of content.  They are doing so either:

  • In the short term because they have made a mistake, or
  • in the long term because they need to revert messaging to a previous point in time.

In the first instance there is likely to be no issue.  Common assets are likely going to be the same as they where at the point in time of the version.  However, in the second case, we really want to see the old content in the context of the current templates, etc.  If we revert, it’s to get the older content, but we’re going to deploy it in the context of the latest look and feel of our site.

Handling versioning in Web CMS is a must have, must do capability.

In Crafter Rivet we considered these use cases fully and drew a distinction between two types of relationships.  Those relationships which are page only  and those which are shared commonly amongst other objects in the system.  When you revert a page or any other object, those relationships which are “page only” will revert to a point in time, while other relationships that are common will continue to align to the latest version of the asset.

To accomplish this we leverage both the native versioning capability of the core repository as well as file organization and patterns.  In short, we organize page-only assets in folder structures that represent the page. Page objects are given names that are based on a hash of the object to guarantee a unique name which means in effect that the versioning of the page only object is “horizontal” in the repository. By horizontal I mean that a new file path is used rather than relying on the version store.  Shared objects like pages or other common assets are stored regularly and rely on the native versioning support.  If you revert a page you will revert to an a state where the page points to a different set of file / file paths — achieving a solution for both use cases we mentioned above.

Snapshots
There are several Web CMS use cases that could require snaphsots and version diffs.  For example, some websites have compliance related issues and thus must maintain versions of their sites so that in the event of a dispute over information communicated via the site they can easily prove what the site looked like at a particular moment in time.  The question for snapshots is:

  • Is this something your organization must have?
  • And if so, is it something that the repository has to do for you?

Our experience shows that this feature, for the general market, is a nice to have.  Most customers don’t take advantage of this capability.  When we looked at this capability in Crafter Rivet, we decided it was not important to support natively within the repository itself.  If a customer needs a snapshot every day we simply include a deployment target that would produce a snapshot.

For those wondering about snapshot rollback; our experience has shown that this particular feature is really not relevant to most customers in day to day operation.  The feature has come in handy as a mechanism for bailing out people who have made sweeping changes to a site (100s of files) and deployed them with little or no QA only to find a broken website after the fact.  In such a case, snapshotting a rollback is a life saver.  With a click of a button you can revert 100s of files.

Crafter Rivet, by design is 100% file based. In such a crisis scenario, a simple file based backup could be used to restore a Crafter Rivet based site to a former state.  In the repository, you are unlikely to desire an actual rollback.  It’s more likely that you will want to keep the broken state and simply fix what is wrong and then redeploy the working site.

Moving Forward

Alfresco v4 is an incredible platform and the move to the core repository unlocks all of that capability and innovation. Crafter Rivet is a platform that made use of all of the functionality in the AVM.  And with our new release, we made the move.  You can as well.  More importantly, if you are using the AVM with Alfresco v3 (or even V2), then Crafter Rivet is the perfect solution for your upgrade.  We can provide parity for most needs with a much better user experience that goes way beyond basic Web CMS needs with the coverage of WEM use cases like integrated analytics and reporting, native mobile application authoring, preview, and presentation, content targeting and personalization, multi-channel publishing and much more.  If you’re new customer to Alfresco looking for Web CMS solutions, Crafter Rivet is a comprehensive WCM/WEM solution, with features that rival some of the major players in the industry.

Click here to learn more about Crafter Rivet

Click here to sign up for a our webinar “Crafter Rivet – The WEM Solution for Alfresco 4″ on April 12th at 1pm

Web CMS on The Alfresco Core Repository (Part 1 of 2)

Posted by on April 09, 2012

I was on a call today with a long time Alfresco WCM customer who would like to upgrade from 3.x to 4.x.  They have been using the Alfresco WCM solution provided by Alfresco in 2006 for many years. As many of you know Alfresco’s original WCM solution is based on a technology called the AVM – Alternative Versioning Model.  The AVM is a separate repository and associated user interface that was constructed to handle a number of WCM related use cases. Alfresco has since enhanced their offering in their “Document Management” repository, which now handles WCM use cases.  As a result, Alfresco has now announced that  the AVM will no longer be offered to new customers.  In discussing the upgrade with our clients on the call today. “It’s time to move to the ‘DM’” was the most responsible message to provide. Existing customers won’t lose support over night, but eventually the AVM will hit its end of life.  You want to migrate at your earliest convenience rather than procrastinating and allowing pressure to build.

It’s also important at this point to abandon the use of the term “DM repository”. DM was used to differentiate from the AVM.  At this point there is only one repository.  The “core repository” is much more descriptive of the architecture going forward.  As Jeff points out in his blog and as I will elaborate here, there are differences in the the AVM and the core repository in terms of features. That said, features and use cases should not be confused. The core repository is every bit as capable of providing a platform for Web content management use cases as the AVM.

At Rivet Logic we have made a significant investment in a Web content and experience management application for Alfresco that we call Crafter Rivet. Crafter Rivet is a 100% open source,  full featured environment that powers 100s of websites and has over 40 man years of development effort invested in it. Initially Crafter Rivet’s authoring and management capability was based on the AVM. When Alfresco made the decision to direct the full force of its innovation on the core repository we knew it was time to convert. Crafter Rivet 2.0 is now based on the core repository, Solr search and Activiti workflow for Alfresco 4 CE and EE.  Making the switch from the AVM to the core repository required a deep examination of our use cases and the features we would have on hand within the core repository.

I thought it would be helpful to share some of that thinking.  Today we’ll look at the differences in these repositories and tomorrow, in a second post we’ll discuss the actual Web CMS use cases that need to be addressed and how we addressed them in Crafter Rivet. Let’s explore!

Unique Features of the AVM

The first thing I want to do is address the question of what the AVM can do that the core repository cannot.  Because we’re comparing repository to repository we’re going to discuss features and not use cases. Note that for simplicity, on occasion we’ll collapse the features of the AVM repository, supporting UI and supporting integration into the single term AVM.  It’s also fair to note that what we’ll discuss here are the aspects of the AVM which exposed through the associated user interface and thus applicable to customer engagements.  There are features/capabilities of the AVM repository that were not fully exposed by the UI.

Sandboxing (more accurately, layering)

Sandboxing is the ability for a user to work on any asset or group of assets within the site without interfering with another user’s work.  For example, a user could modify and even break a template or CSS file and no one would know until and unless the user promoted that broken asset out of their work area.  For non-technical readers, a sandbox is best described as your own copy of the website.  For the technical readers, you can think of a sandbox as a long running transaction — in source control terminology, a sandbox is like a checked out branch of the site.

Sandboxing is a high order feature born out a lower level feature called “layering.” The AVM is constructed of lightweight stores.  Stores can be layered one on top of the other.  The store on the top appears as though it contains the assets within the store layered below it.  If a user places an changed in the top store it appears to over-write the asset at the same path below it.  If we have a base store we’ll call “the stage area” and then a store for each user; say Bob and Alice,  and both Bob and Alice’s stores are layered on top of  the staging area you can see how we create the concept of sandbox.  Alice can see everything in the staging area, but nothing in Bob’s store. Alice’s work is in a “sandbox.”  If Alice pushes her change from her store to the staging area, Bob sees it immediately as if it were in his store.

Multi-Asset Versioning

In the AVM, versions are taken at the store level not per asset. When you place a change in the store, a lightweight version is created for all assets at that moment. Because of this, it is possible to know the state of every object at a point in time relative to a given object. For Web CMS applications, we deal with compound assets all the time.  Consider a webpage. A webpage is not typically a single file asset,  it’s a document that points to other documents: components, images, css, javascript, etc.  When you version a page, you generally intend that entire collection of assets to be versioned along with the page.

The core repository manages each individual asset’s version history independently.  If page X points to component Y there is no innate support within the version system to know what version of Y was in use at any given point of X’s history.

Snapshots / Comparison and Rollback

In the AVM you can label a version and compare one version to another. It is easy to see what files have changed.  Because of this it is possible to create “diffs” from one version to another.  Once you have a diff you can roll back entire check-ins very easily.

Content Forms (Now supported in core)

The AVM user interface used to support a forms capability that was not available for the core repository. The forms engine made it simple to create content capture interfaces through mere configuration.  Today the core repository has a forms capability that is more powerful than what was provided for in the AVM user interface.

Content Deployment (Now supported in core)

An AVM project could be configured with remote content receivers.  There was out-of-the-box support for repository to file system deployment (FSR) and repository to repository deployment (ASR).  Today the core repository provides two deployment mechanisms; Transfer Service and Channel Publishing framework, which combined now exceed the capabilities of the AVM content deployment framework.

Unique Features of the Core Repository

Now lets look at what the core repository has going for it that the AVM repository and supporting UI never got around to implementing.  Again we’ll look at features rather than use cases.

Rules Support

The core repository allows you to attach rules to a folder that execute based on lifecycle events and configurable conditions.  This is extremely powerful and its a feature that was sorely absent in AVM.

Stronger Modeling Support

Both repositories allow us to create types and (more commonly) aspects which contain metadata.  However the core repository allows for associations at the modeling layer. In the AVM, associations were kept only as paths within files.  This turns out to be fine for content delivery but bad for managing the content due to move and rename operations because of the unbounded number of updates you may have to perform. Associations in files also makes it difficult for supporting user experience features in your content management platform.   Users expect a platform to understand it’s assets and how they relate to one another in a way that can be quickly accessed through query.  The core repository can do this innately through it’s use of associations.  The AVM cannot.

Strong Transformation and Metadata Extraction

The transformation and metadata extraction frameworks integrated with the core repository greatly exceed the capabilities of the those integrated with the AVM.  The AVM is only integrated with an XML metadata extraction and transformation. The core repository on the other hand has integrated support for all kinds of metadata extraction and transformation including Microsoft Office documents, images, PDF and many many more.

Powerful, Fine-grained Permissions

The core repository gives us the flexibility to create and manage user access to content in a way that best fits an individual engagement through the use of ACLs (Access Control Lists.)  While the AVM was based on a similar scheme under the hood, these were never exposed through the UI and thus it were not practical to deploy on engagements.  Out-of-the-box AVM exposed a few roles that could be applied broadly to the entire site in each sandbox.

API support

The core repository has much better remote API support.  The core repository supports CMIS, webscripts, and RAAr.  AVM only supports a remote API based on RMI.

Workflow Engine

The core repository has 3 workflow engines integrated with it: Simple, JBPM, and Activiti. Activiti is based on standards and has parity with JBPM, but incorporates a far better management console. The AVM provides workflows based on JBPM integration only.

Search

Full text search support is based on indexing. You index a store. In the AVM universe every web project was made up of many (layered) stores.  It was not practical to index every store.  Although you can configure individual stores for indexing, if every author in the system wants to be able to search their sandbox, you will hit obvious limitations to the approach. The core repository content has only one store which is constantly tracked by a search index which means that search is very current with work in progress.  Alfresco 4 has introduced Solr as one of its search subsystems.  Solr provides capabilities that greatly exceed Lucene, the indexing engine used by the AVM.

Integrations

The core repository has many integrations that allow users to interact with content on their own terms, be it email, WEBDAV, FTP, shared drive, Sharepoint and so on.  With exception to the filesystem projections, these are simply not made available in the AVM.

Native support in the UI and APIs for taxonomies, folksonomies and collaboration features

The core repository has repository service and UI support for

  • Hierarchical taxonomies
  • Tags
  • Comments
  • Content lists

Making Sense of the Differences

By this time you should have a pretty good idea of how the repositories compare from a feature perspective.  Two observations are obvious:

  • The core repository has a had the benefit of deep continuous innovation.
  • The AVM has certain features intended for WCM use cases that will need to be addressed in a solution that leverages the core repository.

Join us tomorrow for a blog post that will demonstrate the use cases that these features were intended to cover and how we addressed all the Web CMS use cases with Crafter Rivet using and capturing the full power and innovation of Alfresco 4 and the core repository.

Click here to learn more about Crafter Rivet

Click here to sign up for a our webinar “Crafter Rivet – The WEM Solution for Alfresco 4″ on April 12th at 1pm Eastern for a further discussion and demos!

HTML5: Features, Functionality and What it Means for Content Management

Posted by on February 01, 2011

HTML5 has been generating a lot of hype lately. So what is all this hype about, and how is HTML5 different from HTML4? HTML5 introduces new elements but also drops some deprecated elements from HTML 4.01. Having been in development for the past few years, HTML5 is the cornerstone of the W3C’s open Web platform – a framework designed to support innovation and foster the full potential the Web has to offer.

HTML4, the last major iteration of the language, has been around for over a decade, and we can all agree that the Web has undergone tremendous changes during that time. What was originally used mostly for displaying static information, the Web has evolved into a dynamic environment where users are constantly exchanging information, communicating and collaborating in real-time. When multimedia was introduced to the Web, plugins had to be created to ensure proper functionality. HTML4 became a patchwork of augmentations to accommodate features of the modern Web. With the advent of social media, video chat and other interactive systems, the average daily Web usage continues to increase as more people are using the Web as a means to communicate with each other. Creating engaging, rich user experiences have become more important than ever before.

Enter HTML5. HTML5 introduces a number of new features that reflect typical usage on the modern Web. Notable features include:

  • Multimedia – tags that allow multimedia to be directly embedded without any plugins
  • Offline & storage – ability to store offline data for Web apps
  • Semantics – a richer set of tags, along with RDFa, microdata, and microformats
  • Device access – geolocation API allows Web apps to present rich, device-aware features and experiences
  • 3D, graphics & effects – natively rendered visuals in the browser
  • Interactivity – drag & drop and other desktop-like features

Does this mean HTML5 will kill Flash, Silverlight and the like? Probably not. But it will definitely play a helping hand when it comes to developing Web apps when mobile compatibility is a concern, now that certain plugins that aren’t supported by many smart phones are no longer needed.

In many ways, HTML5 marks the future of the internet. How will this impact content management? In this digital age, time is of the essence. Consumers want access to fresh, updated content when they need it, where they want it, whether it’s at home through a desktop or on-the-go through a mobile device. Multi-channel publishing is quickly becoming an important part of an organization’s content management objectives. HTML5 facilitates this by making it easier to display Web content in various formats. While HTML5 won’t fully mature for quiet some time, it’s exciting to see what it brings to the table and the potential to influence the future of the internet.

The Future of Enterprise IT – From Systems of Record to Systems of Engagement

Posted by on January 26, 2011

Enterprise IT is a continuously evolving process, just like how our existing Systems of Record were first introduced several decades ago, a new System of Engagement is making its way into today’s organizations. What prompted this system of engagement and what steps should organizations take to effectively incorporate this into their existing infrastructure?

The consumerization of IT has driven enterprises to redefine how they think about information management, control, and governance in order to deal with social technologies. Furthermore, organizations today have become more collaborative in their daily operations in order to better facilitate communication – both internally within departments and externally with global stakeholders. Social business is then, in effect, leveraging social technologies to improve collaboration and responsiveness.

In a recently published report by AIIM, Systems of Engagement and the Future of Enterprise IT: A Sea Change in Enterprise IT, Geoffrey Moore compares and contrasts existing Systems of Record with Systems of Engagement. These system of engagement tools overlay and complement organizations’ investments in systems of record by providing Web-based access, usability across a variety of hardware and software platforms, and cross-organizational collaboration.

The report addresses important questions such as:

  • How will the core value chains within our organizations – innovating, designing, procuring, marketing, selling, servicing, and governing – be impacted by social business systems?
  • What are the issues facing end users who wish to better leverage their information management systems to:
    1. improve operating flexibility, and
    2. better engage with customers?
  • What is the path forward for implementing, sustaining, and managing social technologies effectively and responsibly?

Analysis from the report was reviewed by 20 CIOs and IT executives from major corporations and government agencies and by a Task Force of executives. As a task force member, Alfresco has already started to adopt this System of Engagement by incorporating features into their ECM platform to form a new category of Social Content Management.

For more information and to download the report, click here.

Rivet Logic Earns Alfresco Partner of the Quarter Award

Posted by on November 19, 2009

Alfresco just selected Rivet Logic as the winner of their Americas Partner of the Quarter Award.

Alfresco Partner of the Quarter, Q2 2009 – Rivet Logic

We’re truly honored to be recognized again by Alfresco for our accomplishments. Over the past year, we’ve continued to see strong demand for our Alfresco consulting services as more and more organizations are becoming more liberal towards the idea of open source. Last quarter, we kicked off several new Alfresco projects in a variety of sectors – including higher ed, media/publishing, technology and non-profit.

We look forward to continuing our work with major enterprises, and contributing back to the Alfresco community.

Rivet Logic Named in KMWorld’s “100 Companies That Matter in Knowledge Management”

Posted by on March 02, 2009

KMWorld, the leading information provider serving the knowlege, document, and content management systems market, has selected Rivet Logic in their list of “100 Companies That Matter in Knowledge Management” for 2009.

The announcement was made yesterday by Hugh McKellar, editor in chief of KMWorld.

“We have always maintained that knowledge management is an attitude, not a specific application—a commitment to taking full advantage of all the information at an organization’s disposal and delivering it to the appropriate constituencies to facilitate decision-making at every possible level…

…We believe that each of the companies listed embodies as part of its culture the agility and limber execution of its mission… they embrace a spirit of innovation and adaptability. They each embody the resiliency and wisdom to identify and act upon their own areas requiring improvement and, more importantly, those of their customers.”

We’re honored to receive this prestigious recognition. As leaders in the open source enterprise content management and collaboration market, we will continue to strive to deliver bottom-line results for our customers.

Going Green with ECM

Posted by on October 31, 2008

With the “going green” trend gaining popularity, more businesses are starting to migrate towards a paperless office. Green computing is more than just choosing the right hardware for maximum energy efficiency, it’s also about reducing the amount of paper waste in our daily office operations. Going paperless would not only reduce clutter and increase productivity, but also help conserve natural resources at the same time. Think of all the times you’ve had to look and sort through piles of papers just to find that one small piece of information, all the while making more of a mess to make it even more difficult the next time around. Imagine that multiplied by the number of employees in your organization. That’s a lot of time wasted right?

With the right enterprise content management system, all those paper documents can be managed electronically. Better yet, those items can be tagged with keywords to make finding and sharing that piece of information hassle free. All that time saved can be used more productively. The fact that you’re helping to conserve natural resources is an added bonus. We all want a better environment for our future generations, right?

Baby Boomers Helping With the Enterprise 2.0 Boom?

Posted by on September 05, 2008

With the baby boomers fast approaching retirement, the workforce is making room for a new slue of younger Gen Y employees. What affect will this have on the technologies enterprises currently employ? Along with the influx of a younger generation of workers, will come an increase in the adoption of new technologies. This younger generation of workers grew up using computers and the internet, with “blogs”, “social networking”, and “instant messaging” a part of their daily vocabulary. Gen Y comprises the bright minds of tomorrow. They’re not going to want to work in an environment where the technologies are behind. They’re going to expect the tools at their companies to mirror what they use in their personal lives. Gen Y is going to change the Web in more ways than one.  It would in a sense almost force enterprises to come up to speed with Enterprise 2.0 technologies to recruit and retain the best of this generation.

Out with the old, and in with the new!