Tag: Architecture

Confluence Alfresco Integration for the Enterprise

Posted by on October 05, 2010

Today organizations of all sizes are adopting wiki solutions as a way to facilitate communication and collaboration around planning, projects and departmental matters. Wiki solutions allow users to attach documents to pages and to hyperlink to those documents from other pages. This is extremely useful, however documents, which have traditionally been stored and secured on corporate shared drives are now living in separate places. Some now live within the wiki, while others continue to live on file servers. This is an example of an age-old issue in technology; as we bring in new tools that provide us with more options and better ways to work we are faced managing the side effects of a growing technology footprint.

This issue is not new technology, but instead, one of architecture. As our needs grow we need to adjust our architecture to accommodate new demands. In this case, what we need to do to solve the problem is to separate a few concerns. Some users want to access the document through a file server (shared drive) while others want to access it via the wiki. Traditional shared drive technology doesn’t do a great deal to help us accommodate this. Traditional shared drives provide file system access to documents but lack APIs that allow us to get to our content by more sophisticated means. Further, most wiki technology is one sided as well; while a wiki solution may provide web based access via pages and services they tend to lack file system access. Finally, even if the wiki could “project” its store as a shared drive it’s not likely to be the proper system of record for your documents. By separating the issues of storage, management and delivery we can articulate a solution that allows us to serve documents through a traditional shared drive interface via a proper system of record while at the same time, providing APIs that allow us to get to that content as a service so we can incorporate better ways of working with the document through new technologies as they emerge.

Enter Alfresco. Alfresco is architected from the ground up to be a system of record. It’s designed to provide API / service based access to your documents and content, as well as traditional shared drive access. Alfresco supports three different remote programming APIs including SOAP, webscripts and CMIS. And in addition to presenting itself as a file server so users can connect to it as a file share, Alfresco also mimics an FTP server, a WEBDAV server and even a Microsoft Share Point server. Alfresco is designed to store, secure and manage your documents and to provide access to those documents in the way that best suits your users.

If we use Alfresco to store our documents and integrate our wiki solution to read and write documents though Alfresco’s APIs rather to the wiki itself we satisfy our objectives:

  • Store documents in a proper system of record
  • Allow file-share access to the documents
  • Allow API level access to client applications like wiki

confluence attachments integrated with alfresco

hlgh architecture

Alfresco’s capabilities go far beyond security and content retrieval. Once your documents are in Alfresco they can be searched, workflowed, transformed, translated, versioned and so on and so on, no matter how they are accessed; all through stock capabilities provided by Alfresco out of the box.

At Rivet Logic we see real value in allowing knowledge workers to interact with their content though tools and in whatever process that fits their needs best. At the same time, it’s important to manage content or the same efficiencies that are gained through productive tools and well-designed process are lost due to stove-piped information. The need is real, and given that, we set out to create an open source project that demonstrates a more appropriate architecture and provides a stepping-stone for much greater integration going forward. Najy Nicolas, a “Riveter” from our Boston office has integrated one of the most popular wikis, Confluence, with the management capabilities of Alfresco, the leading open source document repository. We’re calling this project the Confluence Alfresco Integration rivet or CAIr for short. CAIr is open source. You can find downloads, source code and documentation here: http://wiki.rivetlogic.com/display/CAIR/Home

Keep it ‘Lite’ (Part I) : Layer your platform for development agility, performance and lower development costs

Posted by on October 24, 2008

This is Part I of a series that I will be doing on factoring your software architecture for development agility, software performance, and total cost of ownership (TCO).

When object oriented programming first arrived on the scene (25 years ago!), it delivered important concepts: encapsulation, polymorphism, and inheritance. These concepts were designed to help the developer factor code. Proper factoring reduces complexity, redundancy and cohesion. One of the most powerful factoring techniques in programming is grouping for reuse.  Functions, Objects, and Aspects are all code groupings that organize an area of concern for reuse.

Code reuse and other factoring techniques tend toward greater simplicity and development agility. These characteristics have an important and positive impact on cost and revenue. There is no doubt that software development can be an expensive undertaking and at the end of the day it’s always about the economics.

As we have observed, programming languages have been evolving to help manage complexity and make software development more efficient and effective.  As computing power continues to improve, platforms are also evolving to improve development agility.  For example JAVA introduced the JVM and the concept of “write once run anywhere.”  It’s clear that the JAVA platform (as opposed to the JAVA language) provides clear agility over languages compiled to specific machine architectures because it removes the dependence on specific machine architectures by introducing an abstraction; the JVM. It has greatly simplified building, packaging and the distribution of software.

Today scripting languages are mainstream.  Scripting languages are generally loosely typed and are interpreted rather than compiled. There are debates between what might be termed the “systems level programming languages” and “scripting languages.”  Some in the traditional camp cite that scripting languages lack rigor, and claim that it won’t perform when compared to their compiled counterparts.  Those in the scripting community point to “extra work for little value” and complex deployment environments as the other side of the coin.  The communities around PHP, Ruby, Python, PERL, Groovy and others boast impressive development agility characteristics over JAVA, C++, etc.

It’s unlikely that there is anything inherent in the languages available today that drastically change the agility characteristics of development in those languages.  Most of the mainstream languages have similar concepts and differ in terms of syntax.  While some expressions may be quicker in one language over another, it’s unlikely that any of the mainstream language’s syntax will produce agility characteristics that are orders of magnitude above and beyond the others. That is to say, it is not the “PHP” in “PHP” or the “Ruby” in “Ruby on Rails” that makes them faster to develop in. It’s platform and architecture that accounts for the difference.  PHP, Ruby and many other examples are interpreted rather than compiled and this means that when a change must be made to a program there is no need for a recompile and no need for a restart.  Just change the code and (in the case of the web) hit refresh.  In the same way JAVA cleaved an entire effort out of the development process (building for individual architectures), scripting languages have cleaved a massive time sync off the hands of developers by making it easy to modify code “on-the-fly.”   I believe that scripting and compiled languages are not at odds but rather they are complimentary.

The strong typing, static analysis and offline assembly of byte code makes perfect sense for framework or systems oriented code.  This code is not likely to change much in the course of an implementation but is executed frequently. Framework code often defines the performance profiles of a system.  You always want to optimize when possible.  Where there is no absolute requirement for interpretation and no strong value proposition it should be avoided.  That is to say favor compilation over interpretation where interpretation does not deliver significant value.  Don’t make the machine do the same work twice when it can be avoided.

Application level code (as opposed to framework code) changes often.  Developers benefit from the ability to easily write and run code without having to restart servers and perform compilations and deployments.  Application code has a lifecycle and release cycle that is much different from infrastructural / framework code.  This becomes more and more apparent as the framework matures and changes less and less often.  They are two different types of code with two different lifecycles.  Businesses don’t want to spend more time on framework than is necessary.  The value is in the applications and this is where agility matters most.

The optimal approach doesn’t have to be one or the other (although in some cases it is.)  Each platform plays best to a different set of concerns.  In software, a common approach for tackling separation of concerns is called layering.  It is possible to layer a system by using a traditional, compiler based language and platform (such as JAVA) for infrastructure needs while leveraging scripting languages and template technologies (such as PHP, Ruby, Groovy and so on) for the application layer.  By doing so, you combine the success characteristics of both platforms: compensating for weaknesses while playing to strengths. To understand the power and success of this approach, one needs to look no further than Excel; a truly killer application.  Excel is a framework.  You bring the application to it when you build your spreadsheet.  Excel’s (a compiled, c++ based application) power is opened full bore with the VBA scripting environment.

We also see this approach taking hold in the web space with packages like Bean shell, groovy, JRuby, Quercus PHP and so on.  At a recent community conference Alfresco, an open source enterprise content management platform demonstrated SURF, a java based framework that enables developers to code applications in server side Javascript.  Alfresco used the SURF platform to create its new Share application (a Share Point alternative.)  They are moving away from developing in pure JAVA because it just doesn’t provide the agility they need to compete at “internet speed”. Instead, they will continue to build their core repository and framework in JAVA but applications will be built based on SURFs support for Javascript and templates.  It’s powerful and fast as a development platform.  The productivity Alfresco has demonstrated in the last year is truly impressive and a testament to layering the two types of development platforms.  Use the right tool for the job and it will get it done better and faster every time.

I’d like to point out one more important outcome of layering your development platform. In doing so you can greatly reduce the learning curve that one must overcome before one can develop for the system.  A relative few people know how to program in JAVA.  However a great many more people have at least some experience programming in Javascript and even more have experience with PHP.  Why?  That’s simple. Javascript is common on web pages. PHP is offered by almost every ISP on the planet and it has a huge online community from which one can find code examples.  When you layer your system you get all the technical benefits of JAVA on the back end with all the benefits of easy to develop code on the front end (the application) in a way that is open to a very wide range of developers; for example: The core framework written in JAVA and the application consuming that frame-work written in PHP (Quercus PHP is an Open Source, JAVA based implementation of PHP5).

PHP developers tend to be much more available and affordable than JAVA programmers. It’s simple economics.