Category: Collaboration

Real-time and asynchronous collaboration, formerly known as groupware. Sometimes included as part of “Enterprise 2.0”.

Nextcloud: Open source file sync and share

Nextcloud Files is an open source solution for file sync and share. Think Dropbox, but distributed under an open source license (GNU AGPLv3) and installed your own servers. Today I decided to see what their latest release, version 13, has to offer.

Much like any web-based file sharing app you’ve seen, upon logging in to Nextcloud a user is presented with a list of their folders and files. Unlike more general Document Management or ECM repositories where the default mode of operation is typically that there is this giant repository of everything that a user may or may not be able to see, Nextcloud, by default, is user-centric–users see their own folders and files and chooses to share those with one or more team members.

With that said, there is a “group folders” feature that allows administrators to define folders shared by groups of users. That feature is not enabled by default, but it can be turned on in a couple of clicks.

The functionality is what you’d expect from basic file sync and share. You can:

  • Drag-and-drop one or more files into a folder to upload
  • Move, copy, and rename files and folders
  • Preview PDFs, images, and other file types
  • Share folders and files with users and groups, including setting an expiration date after which the item is no longer shared
  • Tag folders and files
  • Favorite folders and files
  • See a filterable activity stream of recent activity
  • Recover deleted documents from the trashcan

In addition to the browser-based user interface, iOS and Android users can download the Nextcloud mobile apps. Windows, macOS, and Linux users can download a desktop app. Regardless of your platform, these apps sync content between your devices and the Nextcloud server. Nextcloud also supports WebDAV, so if you already have a WebDAV client you like, you can use it to manage your files in Nextcloud.

There are a number of useful administrative features in Nextcloud, including:

  • Configuring authentication to leverage LDAP/AD
  • Server-side encryption of data at-rest (although the docs say this is not supported for group folders)
  • Linking to external storage using providers such as Amazon S3, FTP, OpenStack Object Storage, SMB, and WebDAV
  • The ability to federate your Nextcloud server with other Nextcloud or Pydio servers
  • Outlook and Thunderbird integration

If there are features you’d like to see that are not installed by default, they might be available in a community-developed app. Administrators can browse the currently installed applications as well as search for new applications to install without leaving the Nextcloud application. Noteworthy applications include integrations with Collabora Online and ONLYOFFICE, which are two online office suites similar to Google Docs, Metadata, which is an app for showing metadata extracted from files such as images, and Deck, which is a Trello-like kanban board for project management.

If there is nothing in the Nextcloud app store that meets your needs you can always develop your own. The Developer Documentation includes a small tutorial and API documentation.

Installing Nextcloud is quite easy. All you need is a web server, PHP, and a database such as MariaDB or PostgreSQL. The Administration Manual includes installation details. Leveraging that, I had everything up-and-running on an Ubuntu server in about ten minutes.

For the tinkerers in the crowd, you might be interested in Nextcloud Box. It is essentially a case, a hard drive, and a place to put your own Raspberry Pi (model 2 or 3) running the Nextcloud-provided microSD card. Once assembled you’ve got yourself an open source file sync and share server that looks great, is energy efficient, and removes the middleman from your file sharing needs. I’ve got a Synology Diskstation that I really like, but I love the open source DIY aspect of the Nextcloud Box.

Will it work for an “enterprise”?

To be sure, Nextcloud is not a full-scale, Enterprise Content Management repository. But not everyone needs one of those. What is it missing? A traditional ECM repository typically includes features like:

  • Custom metadata models
  • Fine-grained access control
  • Workflow/business process management
  • Standards-based, RESTful API (beyond WebDAV)
  • More complex transformation and rendering options
  • Full-text search out-of-the-box
  • Rules, events, or other “hooks” where custom logic can be added
  • Records Management functionality

Maybe you need those features and maybe you don’t. I often see people install and maintain a traditional open source ECM repository only to use its very basic file-sharing features, never progressing beyond that. If a company is early in its “ECM maturity” and plans to eventually take advantage of the more powerful features, then it’s acceptable to under-utilize your ECM platform for a time. But if the organization just needs a glorified file share that has good sync and sharing functionality with a nice user interface and the ability to manage files via WebDAV, Nextcloud might be the perfect fit.

I should also add that if you don’t want to support Nextcloud yourself, the commercial company behind the project has various pricing plans available based on the number of users and the SLA required.

Using Hubot and Watcher to automate Elasticsearch admin tasks via chat

hubot-avatar@2xAlmost all of my client work is remote. For many projects, that means chat is an essential communication tool. When you and your team essentially live in a chat window it’s nice when your tools can participate in the conversation. Luckily, it’s pretty easy to wire this up. Let me show you how I did it for a recent Elasticsearch project.

Openfire: An open source chat server

Today, hosted chat services like Slack and HipChat get all of the attention. The approach I outline in this blog post will work with those tools too, but on this particular project we’re running an open source chat server on-prem called Openfire. Openfire has been around for a long time. I like it because it is open source, easy to install, and will run anywhere you can run Java.

Because it implements an open protocol called XMPP (aka Jabber) there are a variety of chat clients that will work with it. Openfire ships a web-based client called Spark and some of my teammates use that, but most of the time I use Adium on my Mac.

If you need help installing Openfire, take a look at the docs.

Inbound and outbound integration with Elasticsearch

Once your chat solution is working, it’s time to integrate it with Elasticsearch. For my requirements I needed two “directions” for this integration. First, I wanted to be able interrogate one or more of my Elasticsearch clusters from within chat. This “outbound” integration requires a “bot”. There are many open source bots to choose from and examples of bot scripts working with Elasticsearch. I’ll cover both shortly.

The other direction I needed was “inbound”–I wanted my Elasticsearch cluster to be able to tell the chat server when something is wrong with the cluster. This requires something to monitor the health of the cluster (we use Watcher, a paid add-on from Elastic) and a web hook that can use the chat server API to send messages.

Let me cover the outbound implementation–the bot–first. Then I’ll talk about Watcher and the web hook which make up the inbound implementation.

Hubot: An open source chat bot from Github

There are a number of chat bots out there. I went with Hubot from Github. Hubot is based on Node.js. Hubot scripts are written in Coffeescript. However, if you are new to Node or Coffeescript there are plenty of examples out there so don’t let that stop you from using Hubot.

I used this blog post to get Hubot working. However, there were a few gotchas I should point out:

  • I had to use an old version of node.js (0.10.23). The newer version was having a lot of trouble with one of its dependencies and I got tired of fooling with it.
  • The blog post lists some Linux dependencies you need to install, but it leaves one out that’s critical: libicu. On Centos this is libicu-devel and on Ubuntu it is libicu-dev.
  • The blog post specifies some environment variables that need to be set. If you are running Hubot with Openfire, the HUBOT_XMPP_ROOMS variable needs to be set to the fully-qualified conference room name. For example, if the Hubot username is “hubot” running on a host named “grumpy” the variable should be set to hubot@conference.grumpy.
  • You may have to set HUBOT_XMPP_HOST to the hostname of your Openfire server.

Other than that, you should be able to use that blog post to get Hubot and Openfire working.

Hubot and Elasticsearch

There are Hubot scripts that do all sorts of stuff. One of the fun things about adding a bot to your chatroom is to have it do something silly. Maybe every time someone uses the word “Dude” the bot throws out a quote from the Big Lebowski, for example. So you’ll see lots of stuff like that. But there are also more useful examples out there. Here is the one I started with. The hubot-elasticsearch script knows how to use the Elasticsearch API to spit out information about nodes, indices, allocation, and settings. And it allows you to alias your clusters so you don’t have to constantly tell the bot what your URL endpoints are.

Out-of-the-box, the hubot-elasticsearch project is not compatible with Shield, but it’s a decent start. I made a small tweak to get it to work with Watcher, which I’ll cover next.

Watcher: Monitoring and Alerting for Elasticsearch

This particular client is a paying customer of Elastic, which means they are entitled to paid-only add-ons such as Shield (secures the cluster) and Watcher (for monitoring and alerting).

Watcher is pretty handy and we’re glad to have it, but if you aren’t able to use it for some reason, writing your own tool for running tasks on a schedule isn’t too tough. I wrote something similar using Spring MVC and Quartz, for example. You just need something that will periodically interrogate the cluster and then take some action based on some condition. But if you are an Elastic customer there’s no need to build it. The rest of the post assumes that’s the case.

I’ll let you read the Watcher docs to learn more, but at a high level, a watch consists of a trigger, an input, a condition, and an action. The trigger is the schedule. The input might be an Elasticsearch query or the response from some random HTTP endpoint. The condition looks at the input and then decides whether or not action is needed. The action taken might be to send an email, create some data in Elasticsearch, or invoke a web hook.

For my needs, the web hook action is perfect–if one of my watch conditions is met, like maybe something goes wrong with my cluster and the cluster state goes to red, Watcher will invoke my web hook which will post a message in the chat room. Here’s what the action part of my watch definition looks like:

"actions": {
    "notify_chat": {
        "webhook": {
            "method": "POST",
            "host": "localhost",
            "port": 8008,
            "path": "/chat",
            "headers": {
                "Content-Type": "application/json"
            },
            "body": "cluster_health alert: Someone needs to look at the DEV cluster. It appears to be in a RED state."
        }
    }
}

Watcher can have any number of actions listed for a given watch. In this case, I’m using a single “webhook” action called “notify_chat” that does a POST to a URL running on port 8008. That URL could be anything, and it can include basic authentication.

Web Hook: Spring Boot, Spring MVC, and Smack

I’ve been using Spring Boot lately when I need to knock out a quick RESTful API. In this case, I just needed something to listen to the “/chat” end point. When it is called, the code grabs the message posted to it and uses the Smack API to connect to the chat room and post the message. This webapp is probably less than 10 lines of code and Spring Boot packages it up nicely for me.

If you need help with this part take a look at the Smack API Multi User Chat docs.

Tweaking the bot to allow watch acknowledgement

Watcher can throttle or suppress actions based on a time period (“Don’t tell me about this condition again for 5 minutes,” for example) or explicit acknowledgement. If a watch is triggered that uses explicit acknowledgement, I want to be able to acknowledge that from within chat. You already saw that the Elasticsearch Hubot script can talk to the cluster. It’s pretty easy to tweak the script to allow Watcher acknowledgement.

First, I added a function called “ackWatch” that actually does the work of acknowledging the watch:

ackWatch = (msg, watch_id, alias) ->
  cluster_url = _esAliases[alias]

  if cluster_url == "" || cluster_url == undefined
    msg.send("Do not recognize the cluster alias: #{alias}")
  else
    msg.send("Acknowledging watch: #{watch_id}")

  msg.http("#{cluster_url}/_watcher/watch/#{watch_id}/_ack")
    .put() (err, res, body) ->
      msg.send("Acknowledged")

Then, I added the regular expression that the bot should be listening for:

robot.hear /elasticsearch ack (.*) (.*)/i, (msg) ->
  if msg.message.user.id is robot.name
    return

  ackWatch msg, msg.match[1], msg.match[2], (text) ->
    msg.send text

With that in place, any user in the chat room can acknowledge a watch by typing, “hubot: elasticsearch ack some_watch some_alias” where some_watch is the ID of a watch and some_alias is the nickname for the cluster you’re talking about (like “dev”, “qa”, or “prod”, for example).

Putting it all together: A short demo

With all of this in place, my Elasticsearch clusters can tell the team when something interesting is going on and the team can acknowledge that alert and do preliminary investigation by interrogating the cluster, all from the comfort of their chat window.

The video below shows this working. In it, I create a simple watch that invokes a web hook to post a message to the chat room when a watch condition is met.

The demo uses a simple example where the alert is triggered when the test index is a certain size. But you could easily wire up any watch to the same action, such as when your cluster state goes red or when CPU or RAM reach a certain threshold.

This was relatively simple to put together, but hopefully you can see how you could build on this to automate all kinds of things related to monitoring, alerting, and administration of your Elasticsearch cluster from chat.

9 Things You Must Do to Have a Good Meetup

I spend a fair amount of time encouraging the formation of local community meetups around Alfresco and, when I can, attending many of these in all parts of the world. Alfresco meetups are especially fun because I get to meet people I’ve previously only known through the forums, IRC, or twitter.

I’ve started to identify characteristics of successful meetup groups. I thought I’d share them here and maybe others will add their ideas to the list.

Set an (interesting, relevant) agenda

Some meetups are staunchly anti-agenda. They exist because it is fun for people in the same or similar profession to get together to socialize. These have their place. For Alfresco meetups, however, I think it makes more sense to have a set agenda for each meeting. Sure, the agenda can have a “socializing” item on it, but I don’t think an Alfresco meetup that is based purely on socializing will last.

It’s also important that the agenda be interesting and relevant to your local community. I can’t tell you what that agenda is. You as a local community organizer should know. If you don’t, ask your attendees. Your attendees might be mostly technical. If so, you may have a code-filled agenda. Or, you might be completely non-technical so your agenda will be about end-user issues and solving business problems with Alfresco. I’ve been to some meetups that have a mix of both, so they start with a general interest topic and then split into technical and non-technical breakouts. The key is to know your group and what is going to work for them.

It shouldn’t be up to you to set the agenda for every meeting anyway. Make it a group effort. Or maybe rotate the responsibility.

Share responsibility

Speaking of that, find ways to get more people involved. A lot of these groups start out because one person is particularly passionate about a topic. That’s fine in the beginning, but look for ways to get others involved. It’s less work and it forms a stronger nucleus when others share the burden of the work that goes into consistently providing a quality meetup on a regular basis.

Provide food and drinks

It’s an easy win. A lot of times these meetings happen over lunch or dinner. Providing something to eat and drink helps people make the decision to come to your meetup when they are torn between their usual lunch spot and your meetup. Plus, pizza and beer are cheap crowd pleasers. Of course not everyone drinks beer so it’s a good idea to have something else on-hand, but you get the point.

In small groups, depending on the makeup, you might rotate refreshment duties. Or, try to get someone to sponsor your group and let them pick up the bill.

Foster connections

One of your roles as a community organizer is to act as a connector. You have a unique insight into each of your attendees’ motivation for attending the meetup so when you see two or more people that can help each other meet their goals make that introduction. The more connections you can make the more likely it is those people will return.

You might also consider setting up a channel for collaboration that can happen between meetings.

Publicize your meetup

Once you’ve set a time and a place for your meetup, you’ve got to get the word out. Many local Alfresco communities use meetup.com but there are alternatives. Regardless of where you host information about your meetup, make sure you are listed on the Local Communities wiki page.

If you are a partner and you are hosting or helping organize the meetup, contact your clients that are in the area and give them a personal invitation. You might even follow up on the day of the meetup to make sure they are coming.

If you let me know about your meetup I can help get the word out by inserting a blurb about it into Alfresco’s “Event Roundup” that goes out each month. I can also tweet about your meetup on my account and Alfresco’s.

I think sending out tweets a week prior, the day before, and the day of works pretty well.

Prohibit hard sales/recruiting pitches

If it turns out that your meetup is just an excuse to sell people your products or services, or people are descended upon by packs of rabid recruiters the minute they walk in the door, you’ll kill any chance you have of building something cool and long-term. No one wants to take time out of their personal schedule to hear a sales pitch. If you are a partner hosting the meetup, pay particular attention to this. People may walk in the door skeptical–you don’t want to confirm their fears with a hard sell.

I’m not saying you shouldn’t mention who donated the space or who paid for the sandwiches. If you want to keep getting free space and sandwiches you’ve got to do that. Just be cool about it. I think giving a sponsor two minutes to talk about what they do while everyone is grabbing a drink is reasonable.

As the meetup organizer it is your job to work with the rest of the group to establish ground rules about acceptable behavior and to swiftly (but professionally) deal with people who act outside the norms of your group.

Pick a central location

I live in Dallas, which isn’t just a city, it’s a “Metroplex”, which, roughly translated means, “No matter where you decide to have your meetup, someone’s going to drive an hour or more to get there.” That can make picking a meetup spot tough.

Especially when you are starting out, look at who’s coming and where they are coming from and try to pick a central location. You can try a different location for each meeting, but I’ve found that you will end up just getting a different set of attendees each time based on where the meeting is. There’s no easy answer. The best advice is to pick a central location, near main arteries and mass transit, make sure your start time comprehends traffic patterns at that time of the day, and make your agenda compelling enough that someone will want to make the journey.

Welcome everyone

It is important that everyone feel welcome at our meetups. This idea of inclusiveness is comprehensive. It covers everything from your relationship with Alfresco (Enterprise customer, Community user, partner, employee) to your demography (age, race, religion, sex, orientation). Everyone shares in the responsibility of fostering a welcoming atmosphere and raising the issue with the group its leaders if something is out-of-line.

Have fun!

Last, your meetup has got to be fun. We all sit in mind-numbing meetings as part of our day job. Why would we want to spend  personal time in yet another one? Part of this is about encouraging interactivity. Don’t just have presentation after presentation. Ask the attendees to share short stories about their projects or implementations. Maybe set a common goal to develop an add-on for the community and challenge another local community to do the same.

If you are organizing local community groups around Alfresco and you haven’t yet introduced yourself to me, please do so. I can also hook you into our community of community organizers, which we call Team LoCo (I stole the name from Jono Bacon). And, if you have additional thoughts on what makes a great meetup, please share them in the comments.

Kablink press release goes kerplunk

I don’t know why this rankled me so much. Maybe I should just write it off as somebody’s PR firm getting a little too aggressive. But check out this claim made in an announcement yesterday by open source collaboration software company Kablink (formerly ICEcore):

“The only open source collaboration solution to offer
workflow” (Source)

I know. I had to read it twice.

Maybe Kablink defines “open source” or “collaboration” or “workflow” differently than I do. But solutions like Plone, Drupal, and Alfresco have had workflow of some kind for quite a while. It isn’t like there’s just one other open source collaboration offering out there with workflow, there are several. I’m not sure how Kablink thought they’d get this one past anyone. Maybe they’ll comment here to attempt to justify their claim.

Thoughts on social software and events

It sounds like Ringside has some work brewing around events. I haven’t updated my Ringside source code in a while so I don’t know how much of this can be played with right now but I’m anxious to take a look and you can bet I’ll report back here when I do.

The problem with today’s event sites is that they are too focused (live music, social gatherings, etc.) and too isolated (people have to sign up to use them, they are really only used for RSVP-ing, etc.). I’ve also found that finding interesting events can be tough. I think Meetup.com is a particularly bad offender–they’ve got a weird taxonomy thing going with their events. Their search doesn’t appear to be full-text indexed across meetup names or descriptions. Try to search meetup for “Alfresco”, for example. Although I know there are multiple Alfresco meetup groups out there, you won’t turn up one with a keyword search even with your search scope set to “100 miles of USA”. And when you create an event, it seems like there is a limited taxonomy for categorization. You have to decide if your meetup is about “Software” or “Technology”. Why would I pay them to host an event no one can find attended by a set of people who’s profiles I can only leverage in the context of meetup.com?

This is a sticking point for me. We all belong to different communities with different interests. And sometimes those overlap. Our social graphs shouldn’t be in silos. Neither should the events we attend. Managing your connections across networks together and exposing events to sub-sections of your connections (or across your entire network, regardless of where it is hosted) is really powerful. After all, as Bob says, it is through these events by which we form and strengthen those connections in the first place. Hopefully, this is what you’ll be able to do with Ringside.

His post got me thinking about what I might like to do with events in my own community. So here’s a list off the top of my head. Maybe Bob will comment on how/if this maps to the Ringside roadmap.

Attend/host flag & security settings. An individual ought to be able to publish an event, make public/private settings about that event, and indicate whether they are attending or hosting the event.

Event matching/de-duplication. What would be great is if there was a way to match up events. If I say I’m going to a Wilco concert, and you say you’re going to a Wilco concert, there needs to be a way to figure out if those are the same event.

In-network/same-event notification. Once you figure out two events are the same, people in the same network can discover the fact they share similar interests. The system should facilitate this kind of thing.

Targeted event promo. You should also be able to publicize an event to particular cross-sections of your graph. I might want to host a Ringside meet-up that only goes to my open source/E2.0 friends without spamming my family about it.

Interest level indication. An individual ought to be able to specify whether they are thinking about attending an event or are definitely attending an event. For example, someone might post an event they would only go to if someone else from one of their networks is also going.

Events as tags. Obviously events integrate with the rest of the model. Activity feeds certainly have to know when someone attended an event. But you should also have the ability to tag any item with an event. A photo library app needs to be able to let users tag photos that pertain to certain events, for example.

Event discovery. Events should be easily discoverable by tag/topic, full-text keyword search, by geography, and by attendee. I’d like to see a mash-up between Dopplr and an event database, for example, that knows what kind of events I like to attend and then cross references that with my travel schedule so that if I am traveling to San Francisco, and one of my favorite bands happens to be playing, the site can let me know that, including which of my friends might also be planning to attend (or would attend if they knew I was going to be in town).

Slice-and-dice RSS subscriptions. I should be able to get an RSS feed for each of the following: All events happening in a particular cross-section of my social graph, all events happening in a particular tag/topic, all events in a geography, all events in a particular date range, all events attended by a particular individual in one of my networks, or any combination of these (Live music shows happening in Dallas that my friend Jim is going to).

RSVP options. People should have the option of whether or not to track attendance to an event. Even for an event they are not hosting, they may or may not care who else is attending.

Configurable reminders. People need to be able to choose whether or not to send reminders to attendees. Attendees need to be able to opt out of receiving reminders.

Event ratings, comments, and UGC. People should be able to rate, comment on, and upload content related to an event.

Flexible event types. Events don’t have to be of any particular type. An event is really just a span of time during which something that might be potentially interesting to others is happening. “I’m going to Taco Bell for lunch tomorrow” and “I’ll be spending an hour in the Ubuntu forums Saturday” are both legitimate events that people might want to publish.

Calendar view with the same filtering capability as the “slice-and-dice RSS feeds” requirement. And the calendar ought to be widget-able so that anyone can embed it on their own site.

Standard calendar options for events including start and end time, duration, “all day event”, recurring event. I guess if the event was (or could be exported as) an iCal compliant piece of data that might be enough?

Who’s bringing what. Obviously everyone is familiar with the concept in a social gathering (You aren’t the guy who always just brings the chips, are you? Come on, make an effort, man). But this is also relevant to professional events, particularly for “un-conference” or bar camp type events where attendees are expected to present.

What about an ecommerce component? Maybe you ought to be able to sell tickets for an event. This could open up a can of worms regarding capacity, tiered pricing and availability, ticket authenticity verification, etc., but it might be cool/fun to provide something that could loosen the stranglehold a small number of vendors have on the “live event” market. Just a thought. At the very least, if an event requires a charge, you should at least be able to link to a shopping cart somewhere.

Notes from the Gilbane conference on content management and collaboration

The Gilbane Conference on Content Management and Collaboration wrapped up last week in Boston. This was my first Gilbane conference. The most notable thing about the conference is that all of the sessions are made up of panelists participating in a moderated discussion rather than single speaker, death-by-powerpoint sessions. I found the format refreshing initially, but quickly discovered the downside which is that the panels can easily get way off-topic.

Some rough notes from the conference appear below…

Collaboration Case Studies: Pfizer

  • Pfizer implemented MediaWiki, initially to use as a knowledgebase.
  • Known as Pfizerpedia, the site gets 12,000 unique visitors per month.
  • Key adoption factors were: Seeding the wiki with content, promoting early adoption through key champions, taking advantage of pent-up demand, holding the hands of the users as they learned to use the technology, providing guidelines for acceptable use, integrating the wiki with other content stores (team spaces and formal document management), tracking and reporting on usage and impact
  • Pfizer found that because they lack enterprise search, their wiki evolved into a user-maintained index of sorts. I found it odd that an organization that is so knowledge-centric would lack enterprise search.

Collaboration Case Studies: Mitre

  • This was a great example of Enterprise 2.0 in the real world.
  • Components of their solution: Portal (Oracle), Team spaces (Sharepoint), Search and Expertise Location (Google Search Appliance), Social Bookmarking (Scuttle). If they have wikis or blogs I missed what they are specifically using.
  • Their “Phonebook” app was really compelling. Beyond just being a corporate directory with contact and org info, it allowed users to see what communities everyone belonged to, documents they’ve published, projects they are assigned to, things they’ve bookmarked, and whether or not they are online.

Look at http://www.wikipatterns.com for patterns and anti-patterns around wiki implementations.

According to McKinsey, 40% of the work done in western organizations is Tacit which includes decision making, collaboration, and knowledge management. This is where the focus of IT investments should be.

Mash-ups

Kapow showed a demo of their mash-up maker tool. The simple example was that of being in a spreadsheet and needing to retrieve the stock price for a given symbol. Their point was that not all web sites have an API but with their point-and-click tool you can create REST-based services on top of any web page. In their example, they fired up Kapow, opened the quote.com website within the tool and highlighted the stock symbol field to define it as one of the service’s parameters. They then clicked the stock quote button which returned the price. They highlighted the returned price and defined that as the value the service should return. That’s all they had to do to define the service which they then deployed to a locally running server. They then went into Excel and wrote a formula which invoked the service using the stock symbol in the currently-highlighted cell as the service parameter to return the stock price. Obviously, if quote.com changes their markup, service will have to be redefined, but it was easy to see how business people with little or no technical skills could create their own mash-ups, even when the data sources don’t have an existing API.

IBM showed a demo of their mash-up maker called QEDWiki. They showed how they could build mashups through a web browser. Their tool didn’t provide the service builder–the value of the tool seemed to be bringing together data from existing REST-exposed sources into a single page and being able to do that configuration in the browser. They mentioned a mash-up tool being available at Alphaworks but it wasn’t clear whether or not that was the same package being demo’d.

Opening Keynote

Have you noticed how chummy Adobe and Alfresco are these days? John Newton, Alfresco CTO, and David Mendels, SVP from Adobe, were both on the opening keynote panel. The two were definitely in sync on where they thought content management was going. John said he thinks social computing will drive ECM from being used by 10% of the people in an organization today to being used by 80% or 90% in the near future. He mentioned the Facebook integration that’s been getting so much press lately. David said that content must be service-enabled so that it can be assembled in new ways which plays right into Alfresco’s recent addition of the REST framework.

Mendels also let it slip that Adobe has two hosted content management solutions, both of which run on Alfresco. One is Buzzword, which Adobe recently acquired. The other wasn’t named.

Alfresco says it’s all about connections. Adobe says it’s all about interaction. Seems pretty in-step to me.

WCM Keynote

This was a disappointing mix of closed-source WCM vendors. None of the vendors differentiated themselves at all or offered up anything new or interesting with regard to where WCM is headed.

WCM Analyst Panel

As a general rule, you shouldn’t miss an opportunity to hear Tony Byrne speak. His honesty and straightforwardness is always refreshing at these events. He gave the audience a piece of advice regarding evaluating CMS vendors which was to insist on a bakeoff. He said, “You wouldn’t buy a ferrari by watching the sales guy drive the car around the lot, you’d insist on getting behind the wheel. Why should it be different with a CMS?” I’d add a bit to that. When you do the test drive, you should take your mechanic.

I see many customers making CMS decisions before thinking about who’s going to do the implementation and the customization. Or they wait too long to get a professional services firm involved in the process. Obviously, I’m biased–my ECM practice at Optaros is in the business of helping clients with CMS evaluations and customizations–but the point is to seek advice from subject matter experts. Even if you do a bakeoff, there’s still a lot to learn from the people that have been there that you might not uncover during the bakeoff.

The Future of Collaboration/Enterprise 2.0

I was extremely frustrated with this session. I attended thinking the panel would stick to the topic–Enterprise 2.0. Unfortunately, the discussion was around everything but that. The moderator and the panel seemed to confuse “Web 2.0” with “Enterprise 2.0”. Rather than talk about how Web 2.0 technologies can be applied within an organization to boost collaboration, leverage the power of the social network across the org, and reap the benefits of a less-structured, self-forming, self-regulated approach to Knowledge Management (this is McAfee’s and generally everybody else’s definition of Enterprise 2.0), the entire session was devoted to old ideas around customer engagement, customer-driven product development, and online communities. It was a very extranet/internet-centric discussion which entirely misses the point.

I wasn’t the only one who was frustrated–after asking the panel a question which essentially boiled down to “Is it you or me? Which one of us is confused?” several people approached me to share their disappointment.

Andrew McAfee

This was a panel composed of Frank Gilbane and Andrew McAfee. McAfee has done a lot of research around Enterprise 2.0 at Harvard and is always an entertaining speaker. Unfortunately, the format and the length of the slot didn’t really give him much room to stretch his legs. I did get a chance to ask him if he had done any research into the size of an organization that’s required to get the full network effect inherent in Enterprise 2.0 solutions. He said no one really knows yet what the minimum size is but anecdotal evidence suggests it’s “surprisingly small”. If you are looking for examples of real-world Enterprise 2.0 implementations, you should check out the site he started for capturing Enterprise 2.0 case studies.

Gaim name game

GAIM, the multi-protocol, cross-platform instant messaging client has changed its name to Pidgin. If you’re looking for the “Jabber” entry in the protocol list, it’s been replaced by the name of the protocol that Jabber speaks, XMPP.

Migration tools are marketing, not technical, tools

CMSWatch says that although Trends: Microsoft has released free migration tools for Notes/Domino, it is the custom Notes/Domino code that makes it hard to switch.

I’ve architected Notes/Domino applications as well as solutions on other document management and collaboration platforms and I’ve ported applications from one platform to another. Platform migration tools are usually good at moving apps with little or no customization. The “problem” is, Notes/Domino is often used to develop complex, highly-customized applications. For those, there’s probably no getting around a complete re-development effort if they are to be moved at all.

If you accept that you are essentially starting over for all but the simplest applications, your next problem could be with end-user expectations. A lot of the functionality vendors are just now getting around to incorporating into their offerings has been present in Notes/Domino for some time. If the goal is to port the highly-customized application with a 0% loss in end-user functionality, prepare yourself for a substantial development effort and, potentially, the acquisition and integration of best-of-breed components to keep the app as functional as it was before.

This is probably true for any platform migration project. Although you’d like to think that the end-user requirements are de-coupled from the underlying technology choice, platform-specific features or strengths always seem to find their way from the platform feature spec sheet to the list of features end-users can’t live without. Sometimes, that’s because the platform might have been originally selected because of those strengths (i.e., platform X has strong collaborative features or platform Y has great Office integration, for example). Other times, it is because developers are inherently lazy–features that rely on functionality that comes “for free” or is built-in to the platform are often at the top of the priority list.

I think platform migration utilities are most efficiently used as a marketing tool rather than a technical tool–they give the sales folks an answer to the “what about our existing applications on platform X?” objection. Use them to migrate your simple stuff, then start the real work of planning the migration of your customized apps.