It seems that the focus has been refined, and the vision clarified.

The first time I looked at it, DNA was not a repository. Rather it was something that could federate multiple content stores (e.g. – repository/database/file system). I just wasn’t sure what that something was. I believe that is what led me to question how practical it was.

Now, DNA is a repository. However, with this particular repository you can access multiple content stores via the JCR API.

In my first post on DNA I mentioned two JIRA issues: DNA-55 (RESTful API) and DNA-46 (JCR Implementation). They were supporting features. Now, they are defining features.

The one thing that hasn’t changed is that I still see the value in DNA. I still like the idea of federated repositories. That, and I really like the JCR API.

So, what is the big deal?

First, the ability to access content outside the repository via the JCR API.

Second, the ability to apply JCR functionality (search, versioning, etc.) to content outside the repository.

Third, the ability to federate multiple content stores. Here are a few scenarios where I think this might be practical.

• SVN & File System – The source code may be in a SVN repository, but the build artifacts are on a file system.
• JCR & File System – I’ve worked with a number of clients who maintain their binaries on a file system, but maintain the metadata in a repository (JCR).
• Database (Metadata) & Database (Metadata) – How about comparing the schemas of multiple databases?

There are a few issues though…

According to the reference documentation, DNA is lacking a JCR connector. To me, this is a sore spot. I just described a possible JCR/file system pairing above, but at the moment the repository would have to be a DNA repository.

The database connector is only for metadata, as I just described. That may be a bit limiting. I would like to have added this pairing: Database (Content) & JBoss Cache/Infinispan. Wouldn’t it be nice to compare what is cached with what has been persisted?

The file system/SVN connectors are read-only. A little disappointing. The scenarios I described are now useful only for reporting. The file system connector is read/write. While the SVN connector is currently read-only, work is currently in progress to add write capabilities. It would should be nice to be able to use DNA to persist content to the file system and metadata to a repository.

It appears that the JBoss Cache/Infinispan connectors are really just persistence options for DNA repositories. I’m not sure that they can be used to access content that has been cached outside the context of DNA. Though I could be wrong.

Now I’m left wondering, does DNA have any disk based persistence options? Perhaps it is not via a connector. I didn’t see anything in the reference documentation regarding this point.

Also, a number or rather important JCR features are still missing: queries, observation, and locking. That significantly diminishes my second point above (applying JCR functionality to content outside the repository).

Note: If observation is available as part of the Graph API, why is it not yet available as part of the JCR implementation?

That being said, DNA is still in the early stages of development. I suspect some of these issues may be addressed before the 1.0 release. I still think it is pretty neat even with the limited connectors currently available.

There is one aspect that is particularly interesting. The JBoss Cache/Infinispan connectors. I’ve always thought it would be cool to be able to persist a repository to a distributed data grid/cache. As far as I know, there are no such persistence managers for Jackrabbit. I wonder how much emphasis JBoss is going to place on these connectors. Personally, I think they could be defining features.

That brings me to one last concern. How is JBoss going to market DNA?

Part of me wonders if the JCR implementation shouldn’t be separated and treated as its own project. Then place a great deal of emphasis on the fact that the content can be persisted to a distributed data grid/cache. It could now be treated as a direct competitor to Jackrabbit and offer a distinguishing feature. Finally, allow DNA to focus purely on the federation aspect and the ability to use the JCR API to access content outside of repositories.

We’ll just have to see what the 1.0 release bring us. I’m looking forward to it.

So until next time, good fight, good night.

The answer is support groups. I kid. No, I don’t.

There are a number of alternatives to relational databases. However, for the purposes of this post, I am focusing on persistent, distributed key/value stores.

It all seems to have started with Amazon’s Dynamo.

Clarification: I’m not saying that Dynamo was the first distributed key/store. I imagine most developers are familiar with memcached and products such as Oracle Coherence when it comes to caching and data grids. There is also Berkely DB, a persistent key/value store. However, Dynamo is both distributed and persistent. That, and it seems to have lead (indirectly and directly) to the development of numerous open source implementations as I’ll explain below. It appears that Dynamo and Google BigTable had a one night stand and their illegitimate children formed the NoSQL movement.

In order to understand how today’s key value stores are borrowing heavily from Dynamo, it is worth briefly going over some of its characteristics.

• Fault Tolerance – The data is replicated and/or partitioned.
• Distributed Hash Table (DHT)
• Consistent Hashing – The mechanism behind distributed hash tables.
• Eventually Consistent
• Distributed Consistency

Consistent Hashing

Consistent hashing is a means of looking up a node based on a key. The idea is that a key is generated for each node. When you do a get/put/delete, you use the key to look up the key of the closest node.

For proper descriptions of consistent hashing check out these blog posts:

• Consistent Hashing
• Programmer’s Toolbox Part 3: Consistent Hashing
• Consistent Hashing in memcache-client

Eventually Consistent

CAP Theorem

• Consistent – The notion that all clients have the same view of the data at any given time.
• Available – The notion that the data can always be viewed by all clients at any given time.
• Partition Tolerance – The notion that the system can tolerate physical network partitions at any given time.

The theorem states that you can only have two of these properties at a time. This is interesting because I’ve found that a number of distributed key value stores are sacrificing consistency for availability and partition tolerance.

This is where the notion of eventually consistent comes into play. The idea is that if there are no further updates, the data will eventually become consistent.

For proper descriptions of the CAP theorem check out these blog posts:

• The CAP Theorem
• Brewer’s CAP Theorem

For a proper description of eventually consistent check out this blog post by Werner Vogels (CTO – Amazon).

Distributed Consistency

• Locking
• Multi-Version Concurrency Control (MVCC) -  The idea is that each user views a snapshot of the data based on a point in time.
• Vector Clock – The idea is that each node maintains a local copy of the system state (node event counters), as it knows it, and relies on messaging for synchronization.
• Read Repair – The idea is that rather than having the system prevent conflicts, it will rely on the client to resolve them.

Serialization & Protocols

• Byte Array
• JSON (Binary)
• Java Serialization
• protobuf (Google Protocol Buffers)
• Thrift
• HTTP/REST (JSON)
• memcached

Key Value Stores

There seem to be two types of variations.

• Key/Value Store – The value is arbitrary.
• Document Store – The value is semi structured data (e.g. JSON).

Project Voldemort – LinkedIn

Voldemort is a key value store. It has, by far, the best documentation.

• Replicated & Partitioned
• Consistent Hashing
• Eventually Consistent
• Versioned
• Vector Clock with Read-Repair
• JSON (Binary/Typed), String, Java, protobuf (Google Protocol Buffers), byte[]
• Other
  • Java

Tokyo Cabinet/Tyrant – Mixi

Tokyo Cabinet is a key value store. Tyrant is the server that provides network access to Cabinet.

While I wouldn’t consider Cabinet to be distributed, I had to add it because it is ridiculously fast.

About 1 million inserts in 0.4 seconds fast.

• Replicated (Tyrant – Asynchronous)
• Locking – Read/Write (Transactions are available via Cabinet, but not Tyrant.)
• Write Ahead Logging/Shadow Paging
• byte[], memcached, HTTP/REST
• Other
  • Sorted Keys (B Tree Index)
  • C – pwrite, pread, mmap
  • Thread Safe (pthreads)
  • Cache Flushing – Writes are persisted to an in memory buffer. Once the buffer is full, they are written to disk.

The general consensus is that if your data can fit onto a single server, use Tokyo Cabinet/Tyrant. If not, use something like Voldemort.

Notes

This blog post provides additional information with respect to Tokyo Cabinet/Tyrant. And here is the presentation.

Apache CouchDB

CouchDB is a document store, and because of that it supports search functionality.

• Replicated (Incremental, Shared Nothing, Asynchronous)
• Eventually Consistent
• HTTP/REST (JSON)
• MVCC
• Other
  • Sorted keys (B Tree Index)
  • Erlang – Concurrency
  • Index/Query (Map/Reduce via JavaScript)

Notes

This blog post provides a nice comparison of the differences between CouchDB and Tokyo Cabinent/Tyrant.

Apache Cassandra – Facebook

Cassandra is really a BigTable clone. Think of it as a completely denormalized database. However, it too borrows heavily Dynamo and uses a DHT.

• Replicated & Partitioned
• Eventually Consistent
• Consistent Hashing
• Read-Repair
• Thrift

Notes

You can find two (useful) presentations on Cassandra here and here.

Conclusion

Why are distributed key/value stores gaining momentum? It is simple: performance and scalability.

I like to think of it as an exercise in simplicity. A typical key/value store only supports 3 operations:

• put(key, value)
• get(key)
• delete(key)

That is it!

The problem with databases is that they are difficult to scale horizontally. One solution is sharding. One problem with sharding is that you will likely lose the ‘relational’ aspect due to the performance cost of running a query across several nodes. The other problem is the cost of rebalancing the nodes if additional sharding is needed. Ultimately you will likely end up denormalizing the data. The is the first step on the path to key/value stores.

That being said, there are still use cases where you want to use a database. One case might be search. Typical key/value stores are not going to provide search functionality. However, document stores (CouchDB) and BigTable clones (Cassandra) will. The other resolves around consistency. As mentioned before, these distributed key/value stores are relaxing on consistency in favour of availability and partition tolerance. A common example is banking transactions. I don’t think anyone wants relax on consistency when working with banking transactions.

On the other hand, here is a use case from my own experience where I think a key/value store would be more appropriate.

I used to work on an application for generating and processing insurance applications. There were two steps to this process. The first step was determining if insurance was even available to the applicant. The next step was building a dynamic application for the applicant. For the first step, we maintained a complex set of business rules in our database. Essentially we used the applicant’s zip code and business type to determine if insurance was even available. For the second step, we maintained a list of questions based on the applicant’s insurance type and the carriers available.

The SQL for these operations was quite complex and included stored procedures as a result. A better alternative might have been to denormalize the database and push both the business rules and the applications to a key/value store. That is not to say that we wouldn’t continue to use a database. We would. It is just that the database would be used to enter the business rules/applications. The key/value store would be used to retrieve the business rules/applications. Ultimately, the business rules could be collapsed to a key that is the hash of the applicant’s business type and zip code. The value could be a serialized application. Now we just call get(key) and if the value is null, then there is no insurance available. If it is not, then insurance is available and this is the serialized application. On top of that, the applicant’s can save their application and update it at a later date. So, we might as well persist the application instance to a key/value store as well.

Of course, I have simplified things quite a bit here. However, my point is that this process is not transactional in the sense that banking transactions are. The only writes are for updating the answers, and for all intensive purposes this will be done a single client (the applicant). Concurrency is not really a problem here.

Notes:

This blog post provides a nice summary of the issues surrounding sharding.

Additional Reading – General

Anti-RDBMS: A list of distributed key-value stores

Performance comparison: key/value stores for language model counts

Some Notes on Distributed Key Stores

Evaluating key-value and document stores for short read data

My Thoughts on NoSQL

NoSQL: If Only It Was That Easy

Building Scalable Databases: Denormalization, the NoSQL Movement and Digg

Drop ACID and Think About Data

Readings in Distributed Systems – Great List of Papers

Day CQ5 Product Tour

CITYTECH will be supporting the midwest leg.

4/21 – Minneapolis
4/22 – Chicago
4/23 – Columbus

I’ll be speaking in Columbus while Jeff & Satish will be speaking in Chicago.

It should come as no surprise to anyone that I’m a huge fan of CQ5. At CITYTECH, we call it the Cadillac of web content management systems. In addition to covering CQ5, I’m going to be dicussing aspects of web content management in general. If web content management is important to your business, I think you’ll find a great deal of value in attending.

info/registration

Alfresco Chicago Meetup

I’ll be presenting on CMIS during the “barcamp”.

4/29 – Chicago

Nancy has done a great a job with the Alfresco community events. I always enjoy them. They are casual, informative, social, and a great time in general. I’d strongly encourage anyone to attend regardless of their level of experience with Alfresco.

info/registration

CMS Expo Learning & Business Conference

CITYTECH is going to be presenting on Alfresco (DM/WCM) and CMIS.

4/30 & 5/1 – Evanston (Chicago)

Thursday morning Jeff and Tom will be discussing document management/collaboration. In the afternoon I’ll be dicussing CMIS. Finally, on Friday, John will be discussing web content management.

In addition to Alfresco, CMS Expo will be featuring professional training on Joomla! and Drupal.

info/registration

You can always find my dropping some tweets on Alfresco, Day CQ, CMIS, architecture, and Battlestar Galactica on Twitter.
http://twitter.com/shane_dev

So until next time, good fight, good night.

This is what it all comes down to. A lot of developers tend to write complex code. I think it is a result of the ad-hoc nature of programming. The truth is that it is much more difficult to write simple code. I think there are two facets to writing simple code. One is experience, and the other is patience. Experienced developers are better prepared to write simple code from the start. However, simplicity is ultimately achieved by continuously refactoring the code.

Elegance

The code may be simple, but is it elegant? Elegant code is a sure sign of a great developer. It is no longer about efficiency or effectiveness. It is about pride.

Balance

In order to achieve simplicity and elegance, a developer needs to find the right balance between framework/libraries and code. A lot of developers assume that when a framework/library can be used, it should be. Others insist on writing code without the use of any frameworks/libraries. It is all about finding the right balance between the two.

Cleanliness

If the code is simple, elegant, and balanced then there is no reason why it shouldn’t be clean. It should be formatted and follow the proper naming conventions.

Learning Curve

The breadth and depth of knowledge is not nearly as important as a developers ability and desire to learn. As a matter of fact, I’d say that a significant amount of breadth or depth may be detrimental. It may indicate a lack or awareness or flexibility. It is not about knowing X and Y for years. It is about being able to learn Z in days.

Domination

A great developer dominates the entire code base. While some developers may be comfortable in their area of responsibility, great developers have a need to know and understand the entire code base.

Vision

It is important to consider aspects such as maintainability when developing code. The focus should not just be on whether it is functional or not. A great developer considers the long term consequences in addition to the short term goals.

Well, this is my option anyways. I’d welcome any thoughts and/or suggestions.

So until next time, good fight, good night.

Buzzwords are a lot like reality television shows. Every time one is canceled, two more take its place. You know what else they have in common? They lack originality. They are just putting on a new face.

Zombie Viruses

Actually, buzzwords are a lot like zombie viruses too. Somewhere in a secret lab, a vendor and a research analyst are splicing buzzwords looking to create a more perfect buzzword. Then they go to a conference and discretely drop the buzzword. Next thing you know, you’re holed up in bar with a Winchester picking off evangelists one at a time.

For me, it is being holed up in an IRC channel along with my friends/colleagues and other prominent members of the Java community. I thought I was safe. Then, I see that some of them have actually been infected. The Winchester will suffice for now, but I may need to go sawed off, double barrel style soon.

I guess that means a buzzword is a lot like a reality television show featuring zombies.

Undefined

The thing that really bothers me is when a buzzword is coined, but not defined. Apparently it is an abstract concept that is simply too broad in scope to define. Are you kidding me? Whenever I suggest that a buzzword represents an existing concept or an aggregate of existing concepts, an evangelist tells me that I’m wrong and then proceeds to start talking in gibberish. Seeing as I can’t interpret gibberish, I’m told that I simply do not ‘get it’.

Cloud Computing

Let’s take a look at the latest outbreak. Cloud Computing. Come on, say it together…

“In the Cloud.”

I know, I know. I’d rather shoot myself in the head with a nail gun than have to listen to someone repeat that phrase again.

So what is cloud computing?

Wikipedia

“Cloud computing is a style of computing in which dynamically scalable and often virtualised resources are provided as a service over the Internet. Users need not have knowledge of, expertise in, or control over the technology infrastructure ‘in the cloud’ that supports them.”

This is an adequate definition of utility computing, but we are looking for a definition of cloud computing. One approach to defining cloud computing is to describe utility computing but then say that it is not actually utility computing.

Shortly after, this entry mentions IaaS, PaaS, and SaaS. And for good measure, it tosses in Web 2.0 and other unnamed (buzzwords are still incubating) technologies. I guess you just toss the ingredients into a crock pot and wait. Come back 8 hours later and your enterprise IT solution is ready.

Finally, they say that the term cloud is actually a metaphor for the Internet and that this whole cloud computing thing is about relying on the Internet for the computing needs of users. Wow! What a breakthrough! I never thought about using this so called Internet for computing, and I definitely never thought about using it to perform computing for its users. So, if I understand this correctly, the Internet has computers and it has users? When used together, you can use the computers to do computer ’stuff’ for the users? Sweet.

Distinguishing Cloud Computing from Utility Computing

“For those of us who aren’t totally up to speed on the difference, can you summarize the difference between utility computing and cloud computing (in 75 words or less)?

Lynn: That would be analogous to trying to talk about the differences between electricity and a generator. So, I prefer talking about how one relates to the other, rather than the differences.”

Classic. You know you have a problem when you have to side step the issue of defining the buzzword.

“Cloud computing enables users and developers to utilize services without knowledge of, expertise with, nor control over the technology infrastructure that supports them. It is, almost literally, operating the service in a cloud. That’s a good thing, because many companies lack the ability or desire to work with infrastructure. Utility computing, conversely, provides on-demand infrastructure with the ability to control, scale, and configure that infrastructure. At 3tera, we believe that a utility is necessary in order to build a reliable cloud.”

Someone hand me the nail gun. Seriously. I’m not even sure where to start here. What does ‘utilize’ mean? Are we talking about developing services, or are we talking about consuming them? As consumers of services, we have never been interested in their technical infrastructure/implementation. That is the whole point of services. As a developer, I don’t necessarily need to have a technical understanding of the infrastructure. It certainly helps, but it is not required. If the code is well written, it is portable. It makes no difference whether it is deployed to Tomcat or JBoss. It makes no difference whether the application is clustered or not. What is this ‘operating the service in a cloud’ business? Just because the code has been abstracted from the infrastructure, the services are ‘operating in a cloud’? In that case, every service ever written is ‘operating in a cloud’.

How Cloud & Utility Computing Are Different

“The big news is for application developers and IT operations. Done right, cloud computing allows them to develop, deploy and run applications that can easily grow capacity (scalability), work fast (performance), and never — or at least rarely — fail (reliability), all without any concern as to the nature and location of the underlying infrastructure.”

Once again, we see an adequate definition of utility computing. Once again, that is it.

Ah, Yes. How To Define Cloud Computing…

“Cloud computing describes a systems architecture. Period. This particular architecture assumes nothing about the physical location, internal composition or ownership of its component parts. It represents the entire computing stack from software to hardware, though system boundaries (e.g. where does one system stop and another begin) may be difficult to define. Components are simply integrated or consumed as need requires and economics allow.”

First, take away the infrastructure. Then, take away the software architecture. Finally, lose the system boundaries because they are difficult to define anyways. Done. What are you left with? Anyone? So is the cloud architect merely responsible for selecting a utility computing service? Is that what this is all about?

The author then goes on to say (more or less) that cloud computing is deploying service oriented applications to a utility service. Well, at least this is not gibberish. However, according to that definition, cloud computing itself does not provide any added value. It is simply bundling two buzzwords together in the same package. In my opinion, that repackaging does not count as innovation.

Conclusion

Okay, the title was misleading. Amazon EC2? Go for it. I would.

I’m a fan of utility computing. I think it is a truly novel idea, and that it will have a significant impact on the future of enterprise IT.

My issue is with the buzzwords, and the people who evangelize them.

A buzzword is not an architecture. It is not a solution. You can’t just purchase a product thats been stamped with a buzzword and expect to call it a day.

You need an architect. You need a problem solver. You need developers.

IT is something you do, not something you buy.

So until next time, good fight, good night.

public function downloadFiles(event:DragEvent):void
{
   this.docs = List(event.target).selectedItems;

   var clip:Clipboard = new Clipboard();

   clip.setDataHandler(ClipboardFormats.FILE_LIST_FORMAT,
      getDownloadFiles);

   var dragOptions:NativeDragOptions = new NativeDragOptions();

   dragOptions.allowCopy = true;

   NativeDragManager.doDrag(event.currentTarget as InteractiveObject,
      clip, null, null, dragOptions);
}

I have created a custom class named Document. This class specifies properties for the filename and the URL to the file itself. I then created an ArrayCollection and added some Documents to it.

So, the first thing I need to do is get the items being dragged (Documents).

Then I have to create a Clipboard and add an Array of Files to it. In addition, you have the option of creating a NativeDragOptions. Finally, you have to tell the NativeDragManager to begin the drag by specifying the drag initiator (<mx:List/>), the Clipboard, the proxy image (null), the offset between the mouse and the top left corner of the drag image (null), and the NativeDragOptions.

However, no Files are available when the drag event is thrown. So, I have to add a data handler to the Clipboard to call a separate method that creates and returns an Array of Files. This is why I set the dragged items (Documents) to a class level variable. So that this method can access them.

private function getDownloadFiles():Array
{
   var files:Array = new Array();

   for (var i:int = 0; i < this.docs.length; i++)
   {
      var doc:Document = Document(this.docs[i]);

      var request:URLRequest = new URLRequest(doc.url);

      var header:URLRequestHeader;

      header = new URLRequestHeader("Authorization",
         "Basic " + this.auth);

      request.requestHeaders.push(header);

      var file:File =
         File.createTempDirectory().resolvePath(doc.fileName);

      var buffer:FileBuffer = new FileBuffer(file);

      var loader:URLLoader = new URLLoader();

      loader.dataFormat = URLLoaderDataFormat.BINARY;
      loader.addEventListener(Event.COMPLETE, buffer.write);
      loader.load(request);

      files.push(file);
   }

   return files;
}

There is not much to this method. I simply have to iterate over the selected items (Documents) and create a new File using the filename. Then I have to create a URLRequest using the URL. Finally, I create a URLLoader and load the URLRequest. What I’ve done is wrap the File in a FileBuffer. Then I added a listener to the URLLoader to write its data to the FileBuffer once it has been retrieved.

Here is the code for the file buffer.

public class FileBuffer
{

   private var file:File;

   public function FileBuffer(file:File)
   {
      this.file = file;
   }

   public function write(event:Event):void
   {
      var loader:URLLoader = URLLoader(event.target);

      var fileStream:FileStream = new FileStream();

      fileStream.open(file, FileMode.WRITE);
      fileStream.writeBytes(loader.data);
      fileStream.close();
   }

}

That is all there is to it. I’d say drag and drop is pretty easy with AIR.

So until next time, good fight, good night.

• Content Driven
• Data Driven

I also think it is pretty safe to say that they are easy to build. However, things can get a little dicey when it comes time to integrate services. The fact is that we are implementing reusable functionality as services and that means that our web applications must now include service clients.

That means we are now responsible for maintaining the client and the UI.

Here is a thought. How about we allow the services to generate their own forms and allow the users to interact with them directly? I do not want to continue playing the middle man.

This approach may not be appropriate for every service, but I suspect it is for quite a few. Here are a few services that are often associated with e-commerce web applications.

• Account Management
• Product Registration
• Payment Processing

Each of these is certainly reusable. In addition to the web application, these services may be consumed by customer support, technical support, and/or kiosks. The point is that it certainly makes sense to implement this functionality as services.

However, this functionality is ultimately user driven. That, and our web application is not going to provide any additional business logic with respect to these services. All it is really doing is generating the HTML form, performing validation upon submission, calling the service, and converting its response to HTML.

Perhaps the only issue is how to we provide a consistent UI if we are allowing the user to interact with the service directly. I think the answer is pretty simple. We’ll use Apache server side includes.

Ultimately, there are only three types of responses.

1. Form
2. Form + Validation Error(s)
3. Result

We can further break that down into two types of tasks.

1. Integrate Form with Page
2. Integrate Validation Error(s)/Result with Page

Integrate Form with Page

The first one is pretty easy.

1. User Sends Request to Apache
2. Apache Sends Request to Web Application
3. Web Application Returns Response w/SSI for Form
4. Apache Sends Include Request to Transformation Service
5. Transformation Service Sends Include Request to Service
6. Service Returns Response (Form XML)
7. Transformation Service Applies Transformation to XML
8. Transformation Service Returns Response (HTML)
9. Apache Returns Response (HTML)

I front the service(s) with a transformation service so that they are not responsible for generating the HTML. After all, the service may be used by other applications and those applications may or may not be web applications.

Integrate Validation Error(s)/Result with Page

The second one requires a little more work and is really a two step process (post get redirect).

POST

1. User Sends Post to Apache
2. Apache Sends Post to Transformation Service
3. Transformation Service Sends Post to Service
4. Service Returns Validation Error(s) or Result (XML)
5. Transformation Service Caches Transformed Service Response (HTML)
6. Transformation Service Returns Redirect
   1. Validation Error(s) – Redirect to Form
   2. Result – Redirect to Result
7. Apache Returns Redirect

GET

1. User Sends Request to Apache
2. Apache Sends Request to Web Application
3. Web Application Returns Response w/SSI
4. Apache Sends Include Request to Transformation Service
5. Transformation Service Sends Cached Response (HTML)
   1. Transformation Service Removes Cached Response
6. Apache Returns Response (HTML)

• I was able to demo the CMIS explorer live.
• I was able to demo Sten’s CMIS visualizer live.
• I was able to walk through my prepared OO presentation.

What went wrong?

Adobe Connect

Apparently Adobe Connect is not fully compatible with Linux. I was able to join the meeting without incident. I was able to see the shared screen. Adobe was even able to detect my microphone and once I was assigned speaking privileges I was able to talk to everyone. Seemed like everything was working perfectly. Then it came time to share my desktop. Interesting. How do I do that? Eventually I was made aware that there should be an option under the ’share’ button for ‘my computer’. Of course, that option wasn’t there. Other options were, just not that one.

I had to reboot into Vista. Here’s the thing. I only boot to Vista for syncing my Zune. That is it. I have nothing else installed beside Adobe Flash for testing my CMIS explorer.

Bandwidth

So, I had to start downloading OpenOffice (for my presentation) and Alfresco (to demo the CMIS explorer) when I began the talk. Thankfully I was able to fall back to one of my blog posts on CMIS to help guide me while I awaited the OO download. Eventually it completed, it was installed, and I was able to open my presentation.

Next you know I am finished with my presentation, but I’m still waiting for Alfresco to finish downloading. Again, I was able to fall back to one of my blogs posts on the CMIS explorer to help guide me. Eventually the download completed, I installed Alfresco, and I was able to demo the CMIS explorer live.

Now, I want to demo Sten’s CMIS visualizer. I also started that download back at the beginning of the talk. However, the download kept stalling and it took an eternity to download. So, I fell back to Sten’s post to show some images of it in action. Once again, the download finished and I was able to demo it live.

Questions

There were a few questions.

Am I going to contribute this back to the community? Yes. I just haven’t determined if I’m going to check in the code as Flex Builder project or as a Maven project.

Did I use a Flex framework? No. I haven’t had the need yet, but I am strongly considering Mate.

Does CMIS support other interfaces besides REST/ATOM? Yes. Alfresco supports web services as well. In addition, the specification mentions WebDAV.

I guess I’m getting good at improvising. Anyways, here is my brief (and I mean brief) presentation on Alfresco/CMIS.

So until next time, good fight, good night.

It is responsible for the notion of composition via remoting.

The problem I have with web services is that they are just another method of remoting, and remoting requires messaging. The fact that you are using web services does NOT mean that you have built a distributed system. As a matter of fact, you haven’t. Especially since web services rely on synchronous point-to-point communication. It means that you have mistakenly used remoting as a means of composition.

I don’t have a problem with messaging. I’m down with message queues.
I don’t have a problem with remoting. It is useful for integration.

I have a problem with using remoting as a means of composition.

Can we all agree that remoting (web services) should only be used as a method of integration with non-Java and/or remote clients?

I’ve actually seen organizations where every new feature is implemented as a web service written in Java to be consumed by one or more Java applications. There were no non-Java clients and there were no remote clients. How can any architect justify this?

I’m down with composition & reuse, loose coupling, and other principals often associated with SOA. However, they are best achieved by deploying services as OSGi bundles alongside their clients.

If you need to integrate with non-Java and/or remote clients then simply expose those bundles as web services, but allow the Java applications to run their bundles locally.

So until next time, good fight, good night.

Update: The project is now available on Google Code here.

Or, you can go straight for the download. The current download is for the CMIS 1.0 specification.

Update: I have fixed the code so that there are no more hard coded URLs. It has been tested in both Windows and Ubuntu against both local and remote repositories. Have fun.

Update: I just realized that there is still a hard coded URL in the source. That means it will only work against Alfresco running locally on port 8080. I’ll get that fixed up right away. I’ll be curious to see if it will work against another repository afterwards.

CMIS Services/Features – Done

• Get Repository Info
  • Display the Repository Properties
  • Display the Repository Capabilities
• Get Types
  • Display the ‘Content’ Types
• Get Children
  • Used by the Repository Browser
• Create Document
  • Used by Drag ‘n Drop (from Desktop to Explorer)
• Get Content Stream
  • Used by Drag ‘n Drop (from Explorer to Desktop)
• Query
  • Used by the Search Form

CMIS Services/Features – In Progress

• Create Folder
  • To be used to create folders from within the repository browser.
• Delete Object
  • To be used to delete folders/documents from within the repository browser.
• Set Content Stream
  • To be used to update documents from within the repository browser. Perhaps to be used in combination with check-in and check-out.
• Check-In
  • Perhaps to be used in combination with Set Content Stream to update documents.
• Check-Out
  • Perhaps to be used in combination with Set Content Stream to update documents.
• Cancel Check-Out
• Get All Versions
  • Display document version history from within the repository browser.
• Get Type Definition
  • To be used with Get Types to display the details on ‘content’ types.
• Get Checked Out Documents
  • Display a list of documents that are currently checked out.

CMIS Service/Features – Way Out

Eventually I’d like to get to the remaining services such as those around relationships, allowable actions, and multi-filing.

CMIS Explorer – Images

Before you can browse the repository you have to specify the URL and your credentials.

For Alfresco, running locally, it would look like this.

http://localhost:8080/alfresco/service/api/repository

Repository Properties

Repository Capabilities

Repository Content Types

Repository Browser

This fully supports multiple drag and drop to/from the desktop and application. Simple select files from the desktop and drag them to the list in the middle where the filenames are displayed for existed files. The new files will then be uploaded the repository and the list will be updated. For the other direction, use control click to select multiple files from the browsed (again from the middle list) and then drag them to the desktop. The files will then be downloaded directly to the desktop.

Repository Search

At the moment you have to specify the full query. I’ll likely change that so that you simply specify the keyword(s).

Here are a couple of example queries.

select * from document
select * from document where contains(’a')
select * from document where contains(’a b’)
select * from document where contains(’a') or contains (’b')

So until next time, good fight, good night.