Planet Hippo

Bas van Leeuwen (Hippo): Inspiring: Hippo GetTogether

noreply@blogger.com (Bas van Leeuwen (Hippo)) — Fri, 27 Aug 2010 13:44:00 +0000

So yes, last Friday we had the Hippo GetTogether, our gathering of clients, developers, partners, managers and interested individuals all clad in identical cutesy Hippo shirts. Let me give you an (incomplete) glimpse into the day’s events.

The summer day beckoned, yet everyone decided to stay inside in the magnificent Felix Meritis to listen to an exciting day filled with knowledge sharing. People freely came in and left when they desired, according to Gerrit there was a “good informal vibe” which in my opinion helped to foster an environment for open discussion later on.

Hippo’s very own CTO opened the day with a hearty welcome and after he had shown us what the future of Hippo CMS holds in store it was time for client cases. In this speed-dating for professionals each participant had 4 minutes to show everyone a short glimpse of their Hippo implementations.

TDC Lighthouse used Spring to implement the website of the dutch kidney foundation Not only did we see the big, high-traffic sites for which Hippo is known and loved, but there was also a presentation by Indivirtual about their implementation of http://www.landg.nl in 10 days of work.

The program flowed from these non-technical client cases, through technical cool vs. hot talks ending in an overheated hackathon. Some chose to attend the Usability Sidetrack, in which our User Interface Guru shared some insights into “how we create the friendliest CMS around”. An inspiring workshop in which participants were actively involved in creating ideas for a better product.

Cool vs. Hot focused on using Hippo CMS in new and exciting ways, examples are using Hippo in an “In Memory Data Grid”, integrating Hippo with SAP, SOLR, using REST interfaces, using CMIS, SOAP & Spring, or tips & tricks for running Hippo in a high-performance way.

Afterwards Hippo’s HST expert “Ardcore” gave an introduction into linking with the HST and how to make sure your visitors (and Google!) get where they should be.

We have it all on film, so please have a look at some of the talks, either because you missed them or to review the ideas presented. For example the Liferay-Hippo integration for PvdA.nl

The day ended with a hackathon, complemented with refreshments and pizza. Guys being guys there was no way that the Baywatch-plugin could not have won…

The day ended with a lot of happy faces, see you all next time!

Rolf van der Steen (Hippo): Usability test: Tab Management

noreply@blogger.com (Rolf van der Steen) — Fri, 27 Aug 2010 10:09:00 +0000

A call to Hippo CMS7 authors, editors and admins! Please join in on the next usability test. This one is about Tab management. Use the following URL to start the test:

http://usabilla.com/rate/8190903884c76

Please don't hesitate to join in and speak up. Your opinion is much appreciated!

Note on Usabilla (the tool I'm using for these tests): Participating is anonymous; It is not possible for me to see who has participated. If you like to get in touch personally, please state your email in a note in the test.

Rolf van der Steen (Hippo): Results Hippo GetTogether Usability Sidetrack

noreply@blogger.com (Rolf van der Steen) — Thu, 26 Aug 2010 13:21:00 +0000

Last friday (20 aug 2010) was Hippo GetTogether. Right after lunch, while the Cool vs. Hot tech-talks were being held in the Zuilenzaal, I ran the Usability sidetrack in the Teekenzaal. About 15 people attended and gave me really valuable feedback on Hippo CMS 7.

The sidetrack consisted of two parts. First I presented a brief introduction on usability. Most of the sidetrack however was a practical workshop. In this workshop participants gave me feedback on Hippo CMS 7. For those interested; you can find the entire presentation on http://www.slideshare.net/rolfvandersteen/hippo-get-togehterusabilitysidetrack (yes, I know, it contains a typo).

Check out the presentation if you'd like to know a bit more on usability. Here I like to go into more detail on the workshop and the results from it. For the workshop I had prepared three exercises; “Top 10 Improvements”, “Personas” and “Today's Design”, so that I had at least enough to fill the planned time (13:30 - 15:30). But in the end I used all the planned time and about an hour extra on the first exercise only; creating a decent most-wanted improvements list.

Top 8 Improvements

I used focus group methods to create the improvements list. First I asked all participants to write down their most-wanted improvements on post-its. This could be things like frustrating interaction, bad graphical design or missing features. Then we went through these improvements one-by-one; the 'owner' explained what he/she meant, and we put all the post-its on a flip-over functionally grouping them as we went along. This resulted in approximately 20 improvements. Next we prioritized the improvements. Everyone got to make two votes by placing stickers on the flip-over: one big sticker for the most-wanted improvement (2 points) and one small sticker for the second-most-wanted improvement (1 point).

This resulted in the following top 8 improvements*:

Rich text editor (Xinha): frustrating to work with, doesn't give users true text-editing functionality they expect from Office applications they normally use like MS Word.
Performance: Bad performance influences the user experience, users get frustrated, start clicking more than needed, thus creating more errors.
Document presentation: bad typography, unusable alternating color coding, 'technical' design.
Template creation: current way of creating document type templates is too rigid / clunky.
Workflow: communication possibilities between users in the workflow are missing / too little.
Dashboard: perceived as useless because presented information is not relevant to users.
Tab behavior: frustrating interaction.
Drag & drop: missing functionality.

* The top listing is composed of voted improvements and improvements that are mentioned more than once. All other improvements are left out of the top listing.

Hackathon input

After creating the top listing we came to the conclusion there was too little time left to pick up one of the other exercises. We then had a short brainstorm on input for the hackathon, using the top listing as a reference. We decided improvements for the Dashboard nicely fitted the hackathon goals and could be feasible within a couple of hours.

From this brainstorm the following improvements for the Dashboard arose:

History improvements: make the history list more relevant, show publication, show take offline show requests and their comments, don't dhow login/logout actions, allow user to hide (some) actions, and group actions per user (within a certain time frame).
Chat functionality in CMS: allow logged in users to chat with each other, on dashboard, but eventually across entire CMS, one-on-one chats, but optionally also one-to-many.
ToDo improvements: Group per action.
Change order of history and todo; to do is more important, so should be on the left.

Structured feedback

Another very interesting point which became clear from the usability sidetrack was a clear need for more frequent and better structured ways for Hippo clients/users to provide input/feedback like in this sidetrack. I pointed out that we're running usability tests and that I would like as many participants as possible to join in. I also mentioned that I'm very much interested in additional feedback and like to enable structured ways of exchanging this. Participants responded enthusiastically to that.

What's next?

I've discussed results from the Usability sidetrack at Hippo internally and these are the steps we're going to take:

The upcoming release (7.5) is already fully planned and there are little resources available to pick up additional design and development. However we can fit Tab behavior improvement within this release.
For the next releases we have appointed key usability improvements: Dashboard, Rich text editor, Performance and Document presentation.
Also we're going to create a 'UX channel'. We want to satisfy the need of sharing thoughts and ideas on user experience (and separate these from technical discussions). We have to give it some thought on how we are going to do this, but most likely we'll be opening up a UX forum.

Well, that’s it in a nutshell. I'll keep you updated and hope to see you at the next GetTogether!

Rolf van der Steen (Hippo): Hippo GetTogether Usability Sidetrack

noreply@blogger.com (Rolf van der Steen) — Wed, 18 Aug 2010 06:47:00 +0000

This Friday is Hippo GetTogether. Parallel to the Cool vs. Hot tech-talks I will be running the Usability sidetrack.

The Usability sidetrack is scheduled for form 13:30 until 15:30*. In this time I will give a glimpse into how we create the friendliest CMS around.

First there will be a brief introduction on usability; what is it, what is our vision on it and how do we apply it at Hippo.

Most of the sidetrack however will be a practical workshop. In this workshop you can give us your feedback, directly to me! The feedback will be used right there and then to collectively design and evaluate new and better solutions.

Your input is valuable here! Since the workshop is based on your feedback, please bring your issues, examples, comments, etc.

* There is room and time to continue an extra hour if desired.

Mathijs Brand (Hippo): The little secret about Search Engine Optimization

noreply@blogger.com (Mathijs Brand) — Thu, 12 Aug 2010 16:01:13 +0000

Your average Hippo customer isn't stupid. She's smart. Let's call her Paula. I like that name. Paula. Now let's say Paula is a web analyst and works for a large non profit organization. And because she's smart, she's migrating to Hippo CMS 7. Before she did this, she read some extensive reports on SEO. Her company even hired an SEO consultant to verify her website. But she also noticed a lot of Hippo websites got the highest rankings.

She asked me why. Did I know a little secret perhaps? My answer is yes. I do have a little secret for Paula...

But first I will tell you exactly what Paula knows. So here it goes.

Paula knows

Human Readable URL's are important. Luckily she got it out of the box in Hippo CMS.

Paula knows where the description text in her Google search results comes from. See picture below. Better yet, she knows how she can easily manipulate it in her own Hippo CMS.

A friend of Paula told her about a thing called a sitemap. Although search engines won't promise you they will use it, it is pretty nice if they do: giving visitors an overview of your website in search results. See picture below. The Hippo forge has a nice sitemap plugin using the sitemap standard. The installation is easy. That's why Paula has it now.

Keywords

Things started to get a bit messier with a discussion about keywords. Paula knows it can be a lot of work to add well chosen meta keywords to your pages. She used to give the editors guidelines to try and match all the important search queries in Google; adding keywords for higher search rankings. The editors had entered them extensively in their old CMS and I didn't want to migrate them, for they weren't very helpful at all. Even worse, they were always the same.

Why don't you migrate them? She asked. Google likes them, I read it in my report by the SEO consultants.

So I explained her what a nice job it must be, being an SEO consultant. It seems you can basically write whatever you want. Why? The search ranking algorithm isn't public. So a bit of the mystery remains. I'm not saying meta keywords will hurt your search results. But they won't help you either.
Don't believe me? Check this guy's video:
Google does not use the keywords meta tag in web ranking.

So don't spend your time on keyword optimization for external search engines. Rather spend it on keywords for use within your own website. For example in your own search engine. Try making sure the list of keywords in your article is short and relevant. Then people will find what they are looking for faster and you can influence your website's search results. But searching within your own website is a different topic altogether. I might write about that another time.

Link farms

Very important is the amount of linking between you and other websites. If you link to a normal relevant website and they link back, it's pretty good news for your search results. However a link farming doesn't work. That is bad news for your ranking. Broken links on your website don't help you either, so luckily Hippo CMS has a lot of tooling for that.

Performance matters

Paula didn't know performance mattered for search engines. It does. Check this page by Google about it.

I'm glad speed matters. I like fast websites. And others do too! It will get give your visitors a better feeling of usability. Higher performance leads to more page views. People return more often to fast website. Some people argue it's the most important feature of your website. Anyhow. I'm glad Hippo can provide you with lightning speed.

Nice, nice, nice, but now I want the secret

So you're wondering why Hippo websites rank as high as they do? What is the secret? Is it about all the rules applied above? Partly.

The real secret is your content. There's no smart technical feature giving you high rankings without having relevant content people like. So the amount of pages with nice relevant articles is the little secret I'll give away. And that's exactly what editors in Hippo CMS can focus on. A search term in the title or introduction is more important then a search term in the body. But you don't have to tell people that. They do that already.

And by the way. Paula is very happy and is getting high search results. Are you next?

All characters and events in this blog — even those based on real people — are entirely fictional.

Rolf van der Steen (Hippo): Hippo GetTogether T-shirt poll

noreply@blogger.com (Rolf van der Steen) — Wed, 04 Aug 2010 11:38:00 +0000

To all Hippo GetTogether attendees; now is your chance to determine the looks of us hippotizers. We want you to choose your favorite T-shirt for the Hippo GetTogether (majority rules).

Vote on: http://usabilla.com/rate/19475236134c5

Ard Schrijvers (Hippo): Relevance scoring your search results with the HST Query

Wed, 28 Jul 2010 16:17:32 +0000

Typically, customers like it when a title matches some query, that this item gets scored higher than a match for the query only in the documents body.

Now, without going into the subtle details of Lucene scoring, by default all text in a Hippo Document is indexed with equal weight (assumi

Jasha Joachimsthal (Hippo): Reusing content with Hippo CMS

Jasha Joachimsthal — Tue, 27 Jul 2010 06:01:13 +0000

It may sound very simple, but it's something we have to keep telling: in Hippo CMS you're managing content, not webpages. Even for a simple site as mine, a document can appear in multiple forms. There's the detail page of a blog post which you may see now. You may have seen the title, date, introduction and tags in the overview or the faceted navigation. It's also very well possible that you read this blog post in Google Reader and you have never seen my website at. Now that's already 3 different ways of showing content of the same document.

To be honest, the RSS feed may be a default feature for most systems now, but you can do more with the content. One of the projects I have worked on recently was for a company with several rental locations spread over the country. For each rental location it maintains a document in the CMS with the address data including GPS coordinates. If a rental location is temporarily closed, there's a special field for it in the document. In the front end there are multiple views on that document.

The most obvious is a webpage with the full details of the rental location like the address (and a link to a Google Map), directions, opening hours and optionally the message that the location is temporarily closed.

To get to this view, there's a search box on the homepage with autocomplete for all the locations. This autocomplete list is created dynamically by a query over all rental location documents, the editors don't have to maintain a separate list.

If a visitor of the site ignores the autocomplete list and only enters the city name, he or she will get a list of all rental locations in that city plus a Google Map showing the locations. The pointers on this Google Map are generated on the fly based on the search term the visitor entered.

On the homepage the visitor can click on a link to see which rental locations are temporarily closes. This is to inform customers who use the rental product frequently, that their location is temporarily closed but will be available again. The list, which is hopefully empty, is a result of a query on all rental locations with the special field enabled for "temporarily closed".

Now this is only the content reuse within the site itself. We have also created an HST component that produces a list of all rental locations in KML format. This XML output can be used to import into Google Maps to display a map of all rental locations on an external site. There are also plans to create mobile phone applications to find a rental location near you or a dynamically generated PDF that lists all the rental locations.

All these views are using the same datasource: the documents that represent the rental locations. Every view is generated at request which means that updates are immediately visible.

Are you still maintaining a webpage?

Tjeerd D. Brenninkmeijer (Hippo): Performance does matter..

Wed, 21 Jul 2010 13:54:16 +0000

Google will be using site speed in web search ranking. A quick website is no longer just a nice-to-have as Google is using a new signal in their search ranking algorithms: site speed. Site

Jasha Joachimsthal (Hippo): Show Tweets with HST and Twitter4J

Jasha Joachimsthal — Tue, 20 Jul 2010 21:01:17 +0000

As you may have noticed, my five latest Tweets show up on my site. In this blog I'll explain how you can easily add such a block to your HST site.

For the Twitter component I've used Twitter4J to retrieve my latest tweets. The first step is to add its dependency to your CMS pom:

  <dependency>
  <groupId>org.twitter4j</groupId>
  <artifactId>twitter4j-core</artifactId>
  <version>[2.1,)</version>
</dependency>

Then create your TwitterComponent that extends org.hippoecm.hst.component.support.bean.BaseHstComponent. In your TwitterComponent add a doBeforeRender method that will fetch your latest updates. The quick (and a bit dirty) way is to authenticate using a Twitter username and password. Twitter4J also supports using oAuth which you may prefer over storing your Twitter credentials.

First get a Twitter instance with your credentials (wil be deprecated see update at the end of this article):

Twitter twitter = new TwitterFactory().getInstance([username], [password]);

Then get your Tweets and ReTweets. Twitter does not return a combined list of Tweets and ReTweets because of backwards compatibility so you'll have to combine them yourself. You probably want to show the newest first so you'll have to use a descending sort order based on the ID of the Status.

     try {
            List<Status> statuses = twitter.getUserTimeline();
            List<Status> retweets = twitter.getRetweetedByMe();
            statuses.addAll(retweets);
            Set<Status> allStatuses = new TreeSet<Status>(Collections.reverseOrder());
            allStatuses.addAll(statuses);
            allStatuses.addAll(retweets);
            if (!allStatuses.isEmpty()) {
                request.setAttribute("statuses", allStatuses);
            }
        } catch (TwitterException e) {
            log.warn("Error getting Twitter status updates", e);
        }

To display the 5 newest (Re)Tweets, use this in your JSP (don't forget to add the taglibs):

<ul>
      <c:forEach items="${statuses}" var="status" begin="0" end="4">
        <li>
          <c:choose>
            <c:when test="${status.retweet}">
              RT ${status.retweetedStatus.user.screenName}: ${status.retweetedStatus.text}<br />
              Retweeted at
              <a href="http://twitter.com/${status.retweetedStatus.user.screenName}/status/${status.retweetedStatus.id}" rel="external">
              <fmt:formatDate value="${status.createdAt}" pattern="d MMM H:mm"/></a>
            </c:when>
            <c:otherwise>
              ${status.text}<br />
              <a href="http://twitter.com/${status.user.screenName}/status/${status.id}" rel="external">
              <fmt:formatDate value="${status.createdAt}" pattern="d MMM H:mm"/></a>
            </c:otherwise>
          </c:choose>
        </li>
      </c:forEach>
    </ul>

Note: Twitter4J does not have a caching mechanism yet. Twitter allows you to do 150 API calls per hour (excluding posting updates). If you exceed that limit, it will return a 400 (bad request) instead of your latest (Re)Tweets.

Update about authentication (22-07-2010)

I totally overlooked the warning by Twitter that the basic authentication is going to be shut down from August 16 in favour of oAuth. If you need a quick & dirty way to generate your Autorization secrets, register your application (choose for Application Type client) and read this blog to generate your AccesToken. Then you can get a Twitter instance with:

AccessToken accessToken = new AccessToken([token],[tokenSecret]);
Twitter twitter= new TwitterFactory().getOAuthAuthorizedInstance([consumerKey], [consumerSecret], accessToken);

Rolf van der Steen (Hippo): Usability test: Insert / Modify Image

noreply@blogger.com (Rolf van der Steen) — Thu, 08 Jul 2010 13:57:00 +0000

A call to Hippo CMS7 authors, editors and admins! Please join in on the next usability test.

This test is about inserting and editing images while editing a document. Please use the following URL to start the test: http://usabilla.com/rate/5077836124c35

Please don't hesitate to join in and speak up. Your opinion is much appreciated!

Note on Usabilla (the tool I'm using for these tests): Participating is anonymous; It is not possible for me to see who has participated. If you like to get in touch personally, please state your email in a note in the test.

Rolf van der Steen (Hippo): Results usability test: Done vs. Save and Close

noreply@blogger.com (Rolf van der Steen) — Thu, 17 Jun 2010 07:12:00 +0000

To all participants: thank you!

After just 2 days I've already got a really good amount of feedback.

As can be seen in the results above there is a very strong preference for the "Save & Close" button, as opposed to the "Done" button. We'll be changing this soon.

I also received some suggestions for a "Close without save" button, which would discard changes since last opening a document. We are looking into that.

Jasha Joachimsthal (Hippo): Web development tools I use at Hippo

Jasha Joachimsthal — Wed, 16 Jun 2010 21:01:25 +0000

Earlier this week a customer with its own development department asked us which tools we use for measuring quality and performance of websites. In this blogpost I'll describe some of the tools I use to check the HTML and CSS. I know there are more tools available and it's not a complete list of the tools I use, but I'll cover my most frequently used.

The quality of the HTML and CSS starts at the design phase. Most of the HTML and CSS I see have already been designed, my task is to make the static designs dynamic with content from a Hippo Repository. This doesn't mean I have no opinion at all about the quality of the design. As more people of my age I started making websites as a teenager when frames had just been introduced, Netscape was a faster alternative for Mosaic, tables were necessary for markup and the font tag was accepted. Later CSS was introduced but browsers (IE) had no problem making a webpage out of the tagsoup from Frontpage or Geocities, the horror. Modern professional designers make a clear distinction between HTML and CSS, use HTML elements what they are meant for and think of performance. Some of the tools will guide you towards correct and efficient usage of HTML and CSS.

Web developer toolbar

The web developer toolbar is one of the first Firefox extensions I add. It offers quick access to options you can also find in the preferences of the browser like clearing the browser cache, disable CSS or scripts. Disabling CSS and scripts are sometimes necessary to check if the site is still usable for someone who uses a text browser, read speaker or a (mobile) browser with less features, requirements for Dutch governmental websites. One example are the related dropdowns I made for the thematic search in the website for the national budget. If Javascript is enabled you see the sub category after choosing the main category. Without Javascript you see one dropdown with <optgroup/> to (visually) separate the categories.

Other handy features are shortcuts to validate the current page for correctness of HTML, CSS or even feeds.

Firebug

Firebug is a very handy tool to see the interpreted source of the webpage. This may be different from the HTML response from the server due to DOM manipulation by scripts or the use of tagsoup instead of valid (X)HTML. It also allows you to manipulate the HTML or CSS to quickly see the effect of changing the styling. It can also show you the requests the browser did for the current page, how long they took, and if they were successful.

Yslow

Yslow on top of Firebus gives you performance tips of the page you're working on like "CSS first, then scripts", "Minimize CSS and scripts", "Use a Content Delivery Network" or "Use expires headers". You may start with a Javascript framework (JQuery, Prototype) and one or two scripts. After a few months you discover that there are more than 10 different uncompressed script files on one page. Each of those files need a request, optional check if they can be cached and a response. Yslow will warn you about these things.

YUI compressor

If you end up writing large CSS and script files, it's better to compress or minimize them. For you as developer they're easier to read when you use indentation and variables have sensible names like postalCode, addressAndHouseNumer. For the browser all the whitespace is a waste of bandwith and the variables in scripts may also be called a and b. The YUI compressor can minimize CSS and scripts. If you want it can also "obfuscate" the variables which saves bandwith and as side effect make them harder to reuse (not something you'd want as open source developer).

WAVE

With WAVE I don't mean the chaotic, IRC style collaboration tool of a company that makes money with online advertisements. WAVE is a Firefox extension for checking accessibility of your HTML. It shows you if there are missing labels for form fields, empty or missing alt attributes for images, if there are not too many similar alt texts and if the headers are correct.

Different Internet Explorer versions

Like most of my colleagues I use Mozilla Firefox as default browser. The many useful extensions make it a pleasure to use, despite the occasional memory leak. Most visitors of our customers' website use different browsers, mainly Microsoft Internet Explorer. For me it's a very important reason to keep using Windows instead of switching to Ubuntu on my company laptop. If something works or looks good in modern browsers like Firefox or Chrome it doesn't mean MSIE will behave in the same way. IE8 is a big improvement by supporting more standards than IE7 and by offering development tools that contain functionality I know from the Firefox web developer toolbar and Firebug. With IE8 you can also switch to IE7 rendering but there's still a minor browser we have to support, the antique IE6. For a quick view of how it may render I use MultipleIEs, but if I really want to see native IE6, I have a virtual machine installed. Microsoft offers virtual machines with different Internet Explorers and Windows versions.

Rolf van der Steen (Hippo): Usability test: Done vs. Save and Close

noreply@blogger.com (Rolf van der Steen) — Tue, 15 Jun 2010 08:08:00 +0000

For those of you who don't know me; I'm Rolf van der Steen, User Experience designer at Hippo. It is my responsibility to ensure our products are easy to use and understand, and users will have a excellent experience when using them.

To achieve this I would like to ask for your help. From now on I'll be regularly posting usability tests. These are quick tests focussing on (small) parts of the user interface. The tests will take no longer than a couple of minutes to complete.

I gladly like to invite you to participate in these tests. At this moment the tests will be focussing on Hippo CMS7. Also I'm primarily interested in the opinion of actual end users.

So, are you using Hippo CMS7 as an author, editor or admin? Please don't hesitate to join in and speak up. Your opinion is much appreciated!

And to start of right away; here's the first usability test already. It is a fairly simple test asking wether you prefer a 'Done' or 'Save & Close' button for closing your document. To start the test, please use the following URL:

http://usabilla.com/rate/13889265014c1

Jeroen Reijn (Hippo): An introduction to Hippo CMS 7 updater modules

noreply@blogger.com (Jeroen Reijn) — Thu, 10 Jun 2010 07:45:00 +0000

Once your Hippo CMS project is in production, there is always the case that you or your customer wants to add extra features to the website or portal. This might mean that the data model has to change.
The data model for a piece of content in Hippo CMS is stored based on a JCR nodetype defintion.
As you might know the editor templates, which are related to the data model, can be edited live in the CMS. When you're done editing the editor templates, you can use the 'Update all content' button to persist the changes in your existing content model.
This might be a nice way of doing things during development, but performing such an operation on a live clustered environment can be quite tricky and you might want to do it in a more controlled and tested way.
As of Hippo CMS 7.2 it's possible to perform these changes by writing updater modules in plain Java. In this post I will try to explain the concept of updater modules and will show you how to write these updater modules and use them for updating your data model.

Writing an Updater module

When you start writing an updater module you can start out with the following simple class file:

import org.hippoecm.repository.ext.UpdaterModule;
import org.hippoecm.repository.ext.UpdaterContext;

public class MyProjectUpdater implements UpdaterModule {

    public void register(final UpdaterContext context) {
       .....
    }

}

As you can see in the above code snippet our updater module extend the UpdaterModule interface, which requires you to implement the register() method. In your IDE you will need the hippo-ecm-api library, which comes with the Hippo CMS 7 war package or you can get it from the maven 2 repository.

Updaters and versioning

Performing such an update on your data model is most of the time specific for the current release of your project. The engine behind the updater modules can be instructed to only trigger certain updater modules if certain requirements (like the version of your project) are met. You can instruct the updater engine to trigger a specific updater module by registering a start tag on the UpdaterContext. In the following example we will:

import org.hippoecm.repository.ext.UpdaterModule;
import org.hippoecm.repository.ext.UpdaterContext;

public class MyProjectUpdater implements UpdaterModule {

    public void register(final UpdaterContext context) {
        context.registerName("myproject-updater-v1-to-v1_1");
        context.registerStartTag("myproject-v1");
        context.registerEndTag("myproject-v1_1");
   }
  
}

In the above updater module we will update our project from version 1 to version 1.1.
Our updater module does not do any radical changes so far. It will only change the start version in the repository for our project. You can find the current registered version(s) inside the Hippo repository with the Hippo CMS Console view on the path:

/hippo:configuration/hippo:initialize/@hippo:version.

If you don't have a project specific version yet, I would recommend creating one, because it will help you with using these updater modules.

Now let's continue with some more interesting stuff.

Visitors

You might want to change the data model with some simple operations like: adding a field, removing a field or introducing some new nodetypes. The hippo repository provides several visitors for doing changes inside the repository while performing an update. By default Hippo CMS 7.3 comes with 4 types of visitors. The following diagram shows you the class hierarchy for the ItemVisitor interface.

As you can see the following visitors are available:

NodeTypeVisitor - visits nodes of a specific primary type
PathVisitor - visits nodes based on their path in the repository
QueryVisitor - visits nodes found based on a JCR query
NamespaceVisitor - visits specified namespaces

Of course you can also write your own visitor if you want, but I guess the provided visitors are the most commonly used.

How to use a visitor in your module

Now that we've seen the available visitors, let's see how we can use them. I think the most common use for updaters is when you need to update your data model without any extra processing involved. Let's say our current datamodel (cnd) version 1.0 looks like this:

<hippo='http://www.onehippo.org/jcr/hippo/nt/2.0'>
<hippostd='http://www.onehippo.org/jcr/hippostd/nt/2.0'>
<hippostdpubwf='http://www.onehippo.org/jcr/hippostdpubwf/nt/1.0'>
<myproject='http://www.myproject.org/jcr/nt/1.0'>

[myproject:basedocument] > hippo:document, hippostdpubwf:document, hippostd:publishableSummary

[myproject:news] > myproject:basedocument
- myproject:title (string)
+ myproject:text (hippostd:html)

We want to move to version 1.1, where we added a new subtitle field. The new nodetype defintion now looks like this:

<hippo='http://www.onehippo.org/jcr/hippo/nt/2.0'>
<hippostd='http://www.onehippo.org/jcr/hippostd/nt/2.0'>
<hippostdpubwf='http://www.onehippo.org/jcr/hippostdpubwf/nt/1.0'>
<myproject='http://www.myproject.org/jcr/nt/1.1'>

[myproject:basedocument] > hippo:document, hippostdpubwf:document, hippostd:publishableSummary

[myproject:news] > myproject:basedocument
- myproject:title (string)
- myproject:subtitle (string)
+ myproject:text (hippostd:html)

Now if we want to update our namespace with an updater module our actual code will look like this:

import java.io.InputStreamReader;

import org.hippoecm.repository.ext.UpdaterItemVisitor;
import org.hippoecm.repository.ext.UpdaterModule;
import org.hippoecm.repository.ext.UpdaterContext;

public class MyProjectUpdater implements UpdaterModule {

    public void register(final UpdaterContext context) {
        context.registerName("myproject-updater-v1-to-v1_1");
        context.registerStartTag("myproject-v1");
        context.registerEndTag("myproject-v1_1");
        
        context.registerVisitor(new UpdaterItemVisitor.NamespaceVisitor(context, "myproject", "-",
        new InputStreamReader(getClass().getClassLoader().getResourceAsStream("myproject.cnd"))));

   }
  
}

The updater module above registers a namespace visitor on the UpdaterContext and the visitor reloads the content nodetype definition (cnd in short) from the classpath and updates the namespace to the new version. This is all you have to do to just bump a namespace from version 1.0 to 1.1.

Now if you actually want to change something during the update we can make use of one of the other visitors like the NodeTypeVisitor. Let's say we want to change a certain property of all documents of type 'myproject:news', then this is what the updater might look like:

import java.io.InputStreamReader;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Value;

import org.hippoecm.repository.ext.UpdaterItemVisitor;
import org.hippoecm.repository.ext.UpdaterModule;
import org.hippoecm.repository.ext.UpdaterContext;

public class MyProjectUpdater implements UpdaterModule {

    public void register(final UpdaterContext context) {
        context.registerName("myproject-updater-v1-to-v1_1");
        context.registerStartTag("myproject-v1");
        context.registerEndTag("myproject-v1_1");
        
        context.registerVisitor(new UpdaterItemVisitor.NodeTypeVisitor("myproject:news") {
            @Override
            protected void leaving(Node node, int level) throws RepositoryException {
               if (node.hasProperty("myproject:property")) {
                   node.setProperty("myproject:property", "new value");
               }
            } 
        });
   }
  
}

The important part of the updater in this case is that we override the leaving() method, which will be called before the visitor leaves this node and moves on to the next. It will then change the value of a certain property and move on.

If you want to see more examples of how to use certain types of visitors please let me know, but I hope that the two examples above can help you get started with writing updater modules. Now let's see how to get the repository to run your updater module

Adding the updater module to your deployment

Now that we've seen how to write an updater module, the next step is to get the repository to run your updater module. The Hippo CMS 7 repository knows about the existence of these updater module, but you will need to instruct the repository on where they can be found. Making an updater module available to repository is done in the similar fashion as adding a daemon module to the repository. The location of the updater module needs to be added to the MANIFEST.MF, which will end up in your jar. Maven 2 can help you with achieving this by means of the maven-jar-plugin. See the following plugin configuration from my pom.xml file.

<plugin>
  <groupid>org.apache.maven.plugins</groupid>
  <artifactid>maven-jar-plugin</artifactid>
  <configuration>
    <archive>
      <manifest>
        <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
      </manifest>
      <manifestEntries>
        <Hippo-Modules>com.myproject.repository.update.MyProjectUpdater</Hippo-Modules>
      </manifestEntries>
    </archive>
  </configuration>
</plugin>

Now when you add the jar with our updater module to the CMS web application archive and start the CMS, the repository will scan all manifest files for implementations of the UpdaterModule interface. The updater modules will be registered and triggered when needed.

The updater modules are quite powerful and it's great that you can test them on your test environment, so you can make sure that when you perform an update in production it will succeed.

Vijay Kiran (Hippo): Faceted Navigation with Hippo CMS and HST2

Vijay Kiran — Wed, 02 Jun 2010 12:14:08 +0000

Introduction

Categorizing and presenting large volumes of documents is a big challenge. Content can be organized by

Rolf van der Steen (Hippo): Designing Complex Applications

noreply@blogger.com (Rolf van der Steen) — Fri, 28 May 2010 06:35:00 +0000

From 16 to 18 may I was in London for the training 'Designing Complex Applications'. This training is part of the Usability Week by the Norman Nielsen group.

For those interested; more information on the training:
http://www.nngroup.com/events/tutorials/complex_apps.html
http://www.nngroup.com/events/tutorials/complex_apps_2.html
http://www.nngroup.com/events/tutorials/complex_apps_3.html

I would like to share my two most important insights from this training.

1. Do More User Centered Design

Hippo's development process is very much technology-oriented and requirements are mostly based on internal vision only. The level of UCD should be higher. There are two key elements in this:

Design research (usefulness). Truly getting to know and understand our users; what is the value of our software to them, what is important to them on a deep level addressing feelings and concerns.
Usability testing (usability): once useful functionality has been determined and designed, we should test whether it is usable (before developing it). Note: designed means 'draft design' here; testing with paper prototypes, mockups, partial clickables etc. There are some good methods to do 'guerilla' usability testing (=fast and low cost).

Get out of the building! Do design research to make design decisions data-driven. Without it, we're just guessing. This is all about aligning the users mental model and the designers (and hopefully developer's) conceptual model to create a consistent 'system image'.

This will result in better adoption, higher customer satisfaction, higher ROI, etc (although it is difficult to put some hard numbers on this).

My goals:

Set up methods for design research / usability testing which fit within the Agile process: set up user group, stakeholder interviews, domain investigation
Deliver design artifacts: personas, use cases, mental models, sketches, wireframes, prototypes

2. Make Design Artifacts Tangible

Design is not a 'black art'; transforming data from the design research into 'bits and clicks' can be broken down into distinct tools and steps that anyone can learn and use to improve. I want to make these design artifacts more tangible (to Hippo developers, management and user group) by having it centrally available on our Confluence-wiki. This will help:

Communicate designs and open up design discussions internally
Do remote usability testing
Align stakeholders and end-users concerns/goals, preventing people filling in the gaps with their own different assumptions.
Secure design knowledge
Shorten design process (by means of reusing patterns from a central library)

My goals:

Create a 'UI-place' on Confluence and start filling it in. Note that this will be an ongoing thing (so-called 'living specifications').
Try-out Balsamiq, which is a wireframing/prototyping tool which integrates with Confluence.

Furthermore the training provided a lot of patterns and examples - specifically for complex (web)applications used by domain experts - which are useful to me as source of inspiration / to be in the library.

Hope this gives you some idea of what I've been up to in London and like to hear your opinion on this.

Vijay Kiran (Hippo): Multi Channel Publishing with Hippo CMS and HST

Vijay Kiran — Wed, 26 May 2010 18:42:29 +0000

Introduction

When you are usingHippo CMS, the content and the presentation logic are clearly separated. This cleaner approach to content management allows the users to publish content to various channels with less or no effort. In this post I’ll try to explain how you can setup a multi channel publishing system using Hippo CMS and Hippo Site Toolkit that can serve same content to different channels viz. Web Sites, Mobile (iPhone), iCalendar format and Layar (Augmented Reality Browser).
In this article, I assume that you are a bit familiar with developing a website using Hippo CMS and Hippo Site Toolkit.

What is Multi Channel Publishing?

Multi Channel Publishing represents the execution and/or deployment of communication(s) across any of the various channels (of communication), which includes print, email, mobile, web, podcasts or any other of the existing channels.
– WikiPedia

As an example scenario, consider that you are building an events website with each event having a location, image, date and time etc. You may want to ensure the availability of the data in various channels:

Web Page

The obvious channel to publish your content is a website where people can check the list of events and the details.

iCalendar Format (ics)

You can provide the events calendar in an iCal format so that your site visitors can subscribe to the calendar using their calendar client (iCal, Outlook etc.)

Mobile (iPhone)

You can optimize the site for best user experience by providing a customized version of the webpages specifically targeted for different mobile devices. In our case we will see how we can generate iPhone web application type of interface fort the site using jQTouch.

Augmented Reality Layer

If our events have location information added to them, you can also provide a Augmented Reality layer and publish using a third party service like Layar. Let us see how we can publish to these various outlets using CMS and Hippo Site Tookit.

Content Model

The content model for the event is fairly simple. Each event will have a Title, Description, Date, Image and Location information. You can define the Event as a compound type in the CMS. The CND for the content type will be as follows:

[myproject:event] > nt:base
- myproject:title (string)
- myproject:date (date)
+ myproject:location (myproject:location)
+ myproject:description (hippostd:html)
+ myproject:image  (hippogallerypicker:imagelink)

The location type is just a compound type with longitude and latitude. We can use this for displaying the map and publishing the location information to Layar.

[myproject:location] > nt:base
- myproject:longitude (double)
- myproject:latitude (double)

For adding the location to the document you can use the Google Maps Plugin. This plugin provides a Google Maps widget that you can include in the document template. And allows the user to specify the location by right clicking on the map. I’ll explain how to install/use the plugin in a different blog post.

You can optionally add the boolean fields whether the event is available for Augmented Reality (Layar) or iCal etc. The events page is the document which can have multiple events. The CND for the same is as follows:

[myproject:eventspage] > myproject:basedocument
- myproject:title (string)
+ myproject:events (myproject:event) multiple

As per the content storage structure, all the events documents will be stored under the myproject/events.

Presentation of Data

If you are already acquainted with Hippo Site Toolkit, the next logical step to build your site is to create the Hippo Beans for your content model. I’ll leave out the Hippo Bean details for brevity’s sake.

Web Page

Developing a web page to display the events using HST is very straight forward. You just need to define the sitemap item and a component with template. And link them up together. In our case, http://myproject.com/events/${eventdoc} will map to the myprojects/events/${eventdoc}. You can define the mapping using the HSTConfig Editor or the CMS console. As shown below, The component for retrieving the events is pretty simple.

import com.onehippo.beans.EventsPageBean;
import org.hippoecm.hst.component.support.bean.BaseHstComponent;
import org.hippoecm.hst.core.component.HstComponentException;
import org.hippoecm.hst.core.component.HstRequest;
import org.hippoecm.hst.core.component.HstResponse;
 
public class EventsPage extends BaseHstComponent {
    @Override
    public void doBeforeRender(HstRequest request, HstResponse response)
                       throws HstComponentException {
        EventsPageBean eventsPageBean = (EventsPageBean) getContentBean(request);
        request.setAttribute("doc", eventsPageBean);
    }
}

The template just iterates through the list fo events and displays them. We can use Google Static Maps API to render the a static map on the site. Here’s the relevant JSP snippet for the component’s template:

    <ul style="list-style: none;">
        <li>
          <ul style="list-style: none;">
                    <li>
                        <div class="eventWrapper">
                            <span class="eventTitle">${event.title}</span>, <img style="padding: 5px; margin-left: 5px;" src="http://maps.google.com/maps/api/staticmap?&amp;zoom=10&amp;size=150x150&amp;maptype=roadmap&amp;markers=color:green|${event.location.latitude},${event.location.longitude}&amp;sensor=true" alt="" align="right"> <img style="padding: 5px; margin-right: 5px;" src="${imageLink}" alt="" width="200" align="left"> ${event.description}
                        </div>
                    </li>
                </ul>
            </li>
        </ul>

As you can see this is pretty straightforward and simple. Now let us take a look at how we can publish the events in iCal Format

iCal/ICS format

For the iCal file we can provide a link on the events page users can click and add it to their calendar software. In HST Sitemap you can define a new sitemap item with /events/_default_.ics and map it to the iCal component. For generating the iCal file I used iCal4j library. Here’s the complete code of the component that generates the iCal file.

import java.net.SocketException;
import java.util.List;
import com.onehippo.beans.Event;
import com.onehippo.beans.EventsPageBean;
import net.fortuna.ical4j.model.Calendar;
import net.fortuna.ical4j.model.DateTime;
import net.fortuna.ical4j.model.component.VEvent;
import net.fortuna.ical4j.model.property.CalScale;
import net.fortuna.ical4j.model.property.ProdId;
import net.fortuna.ical4j.model.property.Uid;
import net.fortuna.ical4j.model.property.Version;
import net.fortuna.ical4j.util.UidGenerator;
import org.hippoecm.hst.component.support.bean.BaseHstComponent;
import org.hippoecm.hst.core.component.HstComponentException;
import org.hippoecm.hst.core.component.HstRequest;
import org.hippoecm.hst.core.component.HstResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class EventsPageICS extends BaseHstComponent {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(EventsPageICS.class);
 
    @Override
    public void doBeforeRender(HstRequest request, HstResponse response)
                       throws HstComponentException {
 
        try {
            Calendar calendar = new Calendar();
            calendar.getProperties().add(new ProdId("-//Ben Fortuna//iCal4j 1.0//EN"));
            calendar.getProperties().add(Version.VERSION_2_0);
            calendar.getProperties().add(CalScale.GREGORIAN);
 
            EventsPageBean eventsPage = (EventsPageBean) getContentBean(request);
            List events = eventsPage.getEvents();
 
            for (Event event : events) {
                DateTime start = new DateTime(event.getDate().getTime());
                VEvent calendarEvent = new VEvent(start, event.getTitle());
                UidGenerator ug = new UidGenerator("uidGen");
                Uid uid = ug.generateUid();
                calendarEvent.getProperties().add(uid);
                calendar.getComponents().add(calendarEvent);
            }
            request.setAttribute("calendar", calendar);
        } catch (SocketException e) {
            LOGGER.error(e.getMessage());
 
        }
    }
}

The corresponding JSP template is just a simple one-liner, in which you specify the contentType to be text/calendar:

            <%@ page contentType="text/calendar; charset=utf-8" %>${calendar}

Whenever users visit the http://myproject.com/events/${eventdoc}.ics the browser will automatically open the application that is bound to the mime type text/calendar.

Mobile (iPhone using jQTouch)

You can create a mobile version of the events and make it simple, but using jQTouch the iPhone users will see your site as an application rather than a plain website. jQTouch is a really simple to use iPhone web app library built on top of jQuery. You can sniff the user agent and detect the iPhone browser and render the appropriate content. You can either have a different URL with different component, or you can use the JSP to conditionally render appropriate content if the client is an iPhone. I show how you can use the latter approach. In the EventsPage Component, just add this line:

request.setAttribute("iphone", request.getHeader("User-Agent").contains("iPhone"));

In the JSP Template you can check for the attribute and render the jQTouch. First in the header add the jQTouch library as follows:

    <c:if test="${iphone}">
           <script type="text/javascript" charset="utf-8" src="<hst:link path='/jqtouch/jquery.1.3.2.min.js'/>"/>
           <script type="text/javascript" charset="utf-8" src="<hst:link path='/jqtouch/jqtouch.js'/>"/>
           <link rel="stylesheet" href="<hst:link path='/jqtouch/jqtouch.css'/>" type="text/css" media="screen"
                 charset="UTF-8"/>
           <link rel="stylesheet" href="<hst:link path='/themes/apple/theme.css'/>" type="text/css" media="screen"
                 charset="UTF-8"/>
           <script type="text/javascript">
               $.jQTouch({
                   statusBar: 'black'
               });
           </script>
       </c:if>

And in the body use the display the events using jQTouch, Navigation bar, a table view etc.

    <c:if test="${iphone}">
        <div id="about">
            <div class="toolbar">
                <h1>About</h1>
                <a class="button flip done" href="#events">Done</a>
            </div>
            <ul>
                <li>
                    Hippo CMS & HST Based Website - Optimized for iPhone&trade;
                </li>
            </ul>
        </div>
        <div id="events" class="current">
            <div class="toolbar">
                <h1>${doc.title}</h1>
                <a class="button flip" href="#about">About</a>
            </div>
            <ul>
                <c:forEach items="${doc.events}" var="event" varStatus="st">
                    <li class="arrow"><a href="#event-${st.index}">${event.title}</a></li>
                </c:forEach>
            </ul>
        </div>
        <c:forEach items="${doc.events}" var="event" varStatus="st">
        <div id="event-${st.index}">
            <div class="toolbar">
                <h1>${event.title}</h1>
                <a class="button back" href="#events">Events</a>
            </div>
            <h2>Title</h2>
            <ul>
                <li style="font-size:0.9em;">${event.title}</li>
            </ul>
            <h2>Description</h2>
            <ul>
                <li style="font-size:0.7em;">${event.description}</li>
            </ul>
            <h2>Date & Time</h2>
            <ul>
                <li style="font-size:0.7em"><fmt:formatDate value="${event.date.time}" pattern="dd MMM yyyy HH:mm"/></li>
            </ul>
            <h2>Image</h2>
            <ul>
                <li>
                    <img src="<hst:link hippobean='${event.image.picture}'/>" width="280"/>
                </li>
            </ul>
            <h2>Location</h2>
            <ul>
                <li>
                    <a target="_blank"
                       href="http://maps.google.com/?ll=${event.location.latitude},${event.location.longitude}">
                        <img src="http://maps.google.com/maps/api/staticmap?&zoom=10&size=280x280&maptype=roadmap&markers=color:green|${event.location.latitude},${event.location.longitude}&sensor=true"/>
                    </a>
                </li>
            </ul>
        </div>
        </c:forEach>
        </c:if>

That’s it, now whenever a user visits the same URL with an iPhone the user will get the jQTouch application type of interface instead of a simple website. Of couse, you can extend and link to google maps application on the iPhone as well.

Augmented Reality Layer (Layar)

Layar is an Augmented Reality browser for iPhone and Android. To publish the events via the Augmented Reality application Layar, first you need to get a developer account for Layar. You can get the account for free by going to dev.layar.com. For each layer you want to dislay in Layar AR browser, you need to provide a JSON feed of Points Of Interest via a publicly available URL. The Layar application wll send a GET request along with several parameters, to the URL you provided. In our application, we will create a new Sitemap item that will publish the Layar JSON data for the URL format http://myproject.com/events/${eventname}.poi. You can use this URL in the Layar’s developer interface.

We can create a different component or reuse the existing the events page component that will get all the events. If you use the same component, the only thing you need to do is create a simple JSP page that will render the JSON. You can use json-taglib for rendering the data as JSON.
Here’s the JSP code that will render the data as JSON using json-taglib:

    <%@ page contentType="application/json; charset=utf-8" %>
    <%@ taglib prefix="json" uri="http://www.atg.com/taglibs/json" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
    <%@ taglib prefix="hst" uri="http://www.hippoecm.org/jsp/hst/core" %>
 
    <json:object>
        <json:array name="hotspots" items="${doc.events}" var="event">
            <json:object>
                <json:property name="title" value="${event.title}"/>
                <json:property name="distance" value="100"/>
                <json:property name="attribution" value="attribution"/>
                <json:property name="lat" value="${event.location.latitudeInt}" />
                <json:property name="lon" value="${event.location.longitudeInt}" />
                <hst:link hippobean='${event.image.thumbnail}' var="imgPath" />
                <json:property name="imageURL" value="http://myproject.com/${imgPath}"/>
                <json:property name="line2">
                    <fmt:formatDate value="${event.date.time}" pattern="dd-MMM-yyyy HH:mm"/>                
                </json:property>
                <json:property name="line3" value=""/>
                <json:property name="line4" value=""/>
                <json:property name="type" value="0"/>
                <json:property name="id" value="${event}"/>
                <json:array name="actions"/>
            </json:object>
        </json:array>
        <json:property name="layer" value="${doc.name}" />      
        <json:property name="errorString" value="ok" />
        <json:property name="errorCode" value="${0}" />
        <json:property name="morePages" value="${false}"/>
        <json:property name="nextPageKey" value="${null}" />
    </json:object>

As explained, you’ll get different parameters from Layar request that you can use to process the data. For example, instead of returning all the events, you can just send only the events within the range. More information on these parameters is available in Layar’s documentation.

Layar for iPhone

Conclusion

As you can see, for publishing the data in different formats to different channels, we have not modified anything in the CMS. Using single HST component and different templates, we were able to publish the data. The decoupling in the content management, content retrieval and content prsentation of the Hippo CMS and HST, helps a lot in creating multi channel publishing systems. You can extend it to any kind of channel like RSS Feeds or may be even create a Podcast of the pages using a Robotic Overlord!

If you have any questions or need more explanation don’t hesitate to ask us in our forums!

Jeroen Reijn (Hippo): Giving Hippo CMS 7 some WebDAV support

noreply@blogger.com (Jeroen Reijn) — Mon, 24 May 2010 18:23:00 +0000

A while ago a user on the Hippo CMS 7 forum donated a patch, which provided a servlet for simple WebDAV support. He donated his code as a proof of concept and hoped that somebody with some deeper knowledge of Hippo and it's nodetypes could pick this up and continue to work on it. Since the patch was left alone for quite some time I picked it up and turned it into a Hippo Forge project and called it: 'Hippo CMS 7 WebDAV Support'.

Now and then I find some time to work on this project and the current status now is that I have a working quickstart, which you can check out. I personally think it's far from finished, because there is still a lot of work remaining, but it is already usable. In this post I will explain how the WebDAV plugin works, the current status of the project and some future plans. Let's start with some of the basics.

What is WebDAV?

WebDAV is short for Web-based Distributed Authoring and Versioning. In short WebDAV is an extension on top of the default HTTP protocol and it allows computer users to edit and store files on a remote server. All the major operating systems provide support for WebDAV and will allow you to easily store and edit files on a remote server as if they were on your own computer.

Enable WebDAV support for your Hippo CMS 7 project

Using WebDAV in combination with Hippo CMS 7 is quite easy actually. All you need to do for now is do four things to enable the WebDAV support for your project.

1. Add the WebDAV support maven dependency to your project

<dependency>
  <groupId>org.onehippo.forge.addon.webdav</groupId>
  <artifactId>webdav-addon</artifactId>
  <version>${webdav.addon.version}</version>
</dependency>

2. Add the WebDAV support servlet definition to your web.xml

<servlet>
 <servlet-name>WebDAVServlet</servlet-name>
 <servlet-class>org.onehippo.forge.addon.webdav.HippoWebdavServlet</servlet-class>
 <init-param>
  <param-name>repository-address</param-name>
  <param-value>vm://</param-value>
 </init-param>
 <init-param>
  <param-name>resource-path-prefix</param-name>
  <param-value>/webdav</param-value>
  <description>defines the prefix for spooling resources out of the repository.</description>
 </init-param>
 <init-param>
  <param-name>resource-config</param-name>
  <param-value>/WEB-INF/config.xml</param-value>
  <description>
   Defines various dav-resource configuration parameters.
  </description>
 </init-param>        
 <load-on-startup>5</load-on-startup>
</servlet>

3. Add the WebDAV servlet mapping to your web.xml

<servlet-mapping>
 <servlet-name>WebDAVServlet</servlet-name>
 <url-pattern>/webdav/*</url-pattern>        
</servlet-mapping>

4. Add the WebDAV support configuration file to your projects WEB-INF directory.

This configuration file can be found on the WebDAV support documentation site. It's quite easy to read and you should put it into your /webapp/WEB-INF/ folder if possible.

In action

The following video will show you how easy it is to upload multiple files into the CMS.

Hippo CMS 7 WebDAV support from Jeroen Reijn on Vimeo.

This video is also available on YouTube.

Current status

The current status is that the WebDAV addon has default support for the Hippo assets folder. This was actually quite easy to develop. This can also be used to copy all assets from a CMS 6 instance directly into a running CMS 7 instance. All other folders are not WebDAV enabled yet, but I have some plans for the other folders in the future.

For the short-term roadmap: 'pretty url support' is the first thing I want to work on. I could have put it in hardcoded, but since I want to make it configurable like in the CMS this will my main focus for the next two weeks. If you have ideas or want to help out, please let me know!

Jasha Joachimsthal (Hippo): Components in my blog: Properties component

Jasha Joachimsthal — Mon, 24 May 2010 09:01:11 +0000

This blogpost is about the Hippo Forge Properties component. This component allows you to manage labels for your website instead of hardcoding them into the JSP.

My website is mostly an extended version of the Hippo Site Toolkit demo project. I did a complete HTML and CSS (re)design but the core components look a lot like the original demo. My blogpost document type contains only a few more fields for keywords and keyword suggestions compared to the original text document. In the comment document type I added fields so you can fill in your email address (which I will never publish) and website (which I will publish unless you're trying to send spam).

The properties component is extremely useful to avoid hard coded labels in your rendering templates, in my case the JSP's. The values of the labels are managed from the CMS so if you want to change a common navigation element like "previous" to "previous page" you don't have to do a new deploy of your site. At this moment it is used for the labels of the month facets when navigating through the blogposts. The faceted navigation returns values from 0 to 11 but I rather display them as January to December.

After adding the properties component to the CMS you get a new document type for maintaining the properties. This document type contains repeating key-value pairs, e.g. "month.0" as key for label "January". Then add the necessary dependencies and configuration to the site project. In your own default component or in a specific component add the code that adds the key-value pairs to the request for the rendering templates. You can find examples in the documentation how to add this to your own site. In my case I added it to the HST component that handles the listing of the faceted navigation.

This is how my JSP code looks like to display the label of a month:

<c:set var="labelkey" value="month.${facetvalue.name}" />
   ${labels[labelkey]}

Mathijs Brand (Hippo): There's a Hippo on my Ipad

noreply@blogger.com (Mathijs Brand) — Tue, 18 May 2010 06:01:14 +0000

Okay, okay, so it won't be your favorite editing tool, but the Ipad surely looks a lot cooler with a Hippo on it!

Jasha Joachimsthal (Hippo): First blogpost in Hippo

Jasha Joachimsthal — Mon, 17 May 2010 20:01:31 +0000

This is my first blogpost written in Hippo CMS

I wanted to build my own website and get rid of the tagsoup produced by Blogger. That's why I built my own site using Hippo CMS and Hippo Site toolkit. It's not finished yet (is a website ever finished?) but it's getting close to what I had in mind.

Building this site was one of the reasons I had not written any blog post in months. It took a bit more time than I thought. I had to think what I wanted, played with HTML5 and CSS3 and eventually write some code that tied it all together. In the end I had to configure Apache HTTPD which is something the sysadmins normally do (thanks Bart & Bartosz for your hints). Thanks Hippo for hosting my new blog :-)

Mathijs Brand (Hippo): Smoothly going through a Hippo CMS project

noreply@blogger.com (Mathijs Brand) — Sat, 08 May 2010 02:04:00 +0000

Jboye 2010 has come to an end. The Jboye conference is about getting CMS expert users, analysts and vendors together. The central idea is to learn more by communicating openly. This means I shouldn't too obviously put marketing messages in my sentences, so you can have interesting discussions and get to the point. I like this idea since it's very close to communicating in an open source project. A project like Hippo CMS for example, the best and most user friendly CMS in the world, especially if you have huge amounts of content. Java developers love it. By the way, here's one of those cute Hippo toys.

My first day at the conference I selected a tutorial course about rapid prototyping by James Hobart. Prototyping helps in getting expectations aligned quickly. It's not all that easy to turn the ship around once it's close to the harbour, so it makes sense to make a prototype early in the project. It's an investment, but a very important one.

That's why prototyping combined with SCRUM became a common practice at Hippo. I don't want to keep all the success to myself, so I'm sharing a couple of best practices for a Hippo CMS project in this blogpost. If anything is too technical, please say so. If you think you do it better, please share. If you don't know SCRUM, this is a very fast video introducing you to it under 10 minutes. A sprint takes about two weeks depending on the size of the project and your personal preferences. In small projects a sprint and a phase is the same thing. In larger projects a phase takes one or more sprints.

The business case

The most important part of a project is not part of the project. It's about getting your business case straight. A question you should ask yourself: why are we actually doing this? Which audience do we target and what value does it have for our business. In other words: describe your targets. Once this is clear, don't forget to share your carefully designed ideas. I share the business goals and targets with everyone participating in the project. Even when it's unessential for someone's day-to-day job. In the end this understanding delivered better and more consistent projects. At Jboye I had the pleasure to meet Christine Pierpoint. She had inspiring ideas you should take into account before starting a web project and in this video some of these interesting thoughts will come to you.

The design phase

The (user action) designers can take on the business case and start designing: screen-shots, scratches, wire-frames, anything concrete. Details are not important yet. Keep your focus on the absolute minimum the project needs to go live with. The reason I always focus on the bare minimum is because a) it's nice to get fast results, b) search engines can start indexing your website, c) your marketing people can get going, d) it's easier to end up with something, surprisingly this is not straightforward . A Hippo project has a very solid foundation, so don't worry about adding modules and features after going live. That is, if you make sure you have some Hippo certified developers on your team.

A clickable website

The goal of this phase is to get a real website with HTML, javascript and CSS up and running. No connections to any database or repository. Just plain text, easy programming. I don't like latin texts in a design, because people don't seem to understand what these "lorem ipsum" texts are about. It's confusing, so better use good examples or even texts describing the sort of content that should be there. A functional design can be helpfull for details, but nothing beats having a go at something similar to the end product. I make every link clickable, to make sure the interaction is clear. The clickable website will give you valuable feedback fast. Developers, designers, managers, editors and end users can all have conflicting ideas. Discussions in this phase are necessary. Don't avoid them, but end up with conclusions everybody agrees upon. Your clickable website will help you focus.

About the tools used for a clickable website:
Hippo developed guidelines to make the web design extensible and accessible, however Hippo CMS doesn't impose any technical restrictions on your web design. You're really free to do whatever you're used to do. My team usually creates a simple maven project, use svn for versioning, jsp for coding and jetty to run it all. We created a lot of code snippets for paging, calendars, faceted navigation, related items, forms, header and footer templates, etc. Hippo has support for any javascript library you would like to use, although we tend to use jquery. Don't use more than one javascript library. It ruins your performance. Because projects requirements tend to change all the time during this phase your precious code turns into spaghetti quite easily. That's why we usually keep the clickable website as a seperate project. You can take a different approach and use your own tools or use Hippo Site Toolkit from the start.

The content model and architecture

While frontend developers, end users and business people are getting together to focus on the look and feel of the website, extranet or intranet. The analysts can work on the content model and architecture. You can start at the same time the clickable phase starts and of course there's some overlap. Take your time during this phase to get a good overview of the content model. It's essential for any CMS project. I like to use an excel sheet to describe all the templates, but anything will do as long as it's clear. A news page for example can have a title, a date used for sorting, an introduction, a rich text field, a multiple thumbnail picture or whatever you would like it to have. Don't forget to describe metadata. A simple website has a couple of templates, for example a news template, a simple text template, a template for adds and so on. Define them. Hippo CMS is content driven, so you're defining content types, not web pages.

Next to the model, it's smart to define a good way to structure the actual content in folders, so make a basic setup with a folder for news items or a folder for the communication department depending on your preferences. Editors have an opinion about this, so ask them. The way you structure your content doesn't have to be the same way you structure your website. In Hippo Site Toolkit you can query the content anyway you like. Questions to help you get your answers: Where does each type of content come from. Does the content come from an external source like a webservice or rss feed? Which groups of editors add which content, for example do you have a group of people only editing news pages? If that's the case you help editors a lot by only showing the news pages in Hippo CMS. It's more user friendly and secure.

Hippo CMS and data entry

Because of the Hippo CMS architecture, you can first get Hippo CMS up and running and later further develop your website. This means content migration can take place first and editors can start entering content before the project is finished. That is, as long as you have your (test / acceptance) servers up and running. Even though Hippo CMS is very user friendly, a training course and custom documentation for editors can help to get going fast and consistent. The training material can also be used for writing guidelines. Do you have to migrate a lot of content and you're stuck with tons of xml files? This tool comes in handy. Changes in your content model are more expensive from this phase onwards, but not impossible. If you need to make a change, do it, but only if you're sure you really need it. More info for developers on: http://www.onehippo.org/.

Adding features and phases recursively

Your project is growing and growing and soon your real website starts to look better then your clickable website. You can add sprints until the end of your project's lifecycle, so don't put too much pressure on the first time you enter the world wide web.

Champagne

I congratulate you for reading this and hope you share a glass of champagne with me once your own Hippo CMS project goes live, so feel free to contact me even if it doesn't go as planned. We wouldn't leave you out in the cold. For guarantees and a healthy relationship Hippo offers support.

Mathijs Brand (Hippo): Limited choices

noreply@blogger.com (Mathijs Brand) — Fri, 07 May 2010 17:57:00 +0000

I don't like to make choices. For me the best choice in life is - no choice at all. For example: I like to drink coffee. Any kind is fine. Still I get questions: Do I want the coffee with a touch of frost that gives a dreamy feeling on a lazy afternoon thanks to a selected combination of superbly engineered beans made by an ancient line of distinctive coffee entrepreneurs? Or maybe I would just go for the high-quality coffee which maintains endurance in taste while ensuring a fresh, consistent kick every time I hear the sound of a whisper? I don't know... just give me strong coffee without milk or sugar. And why don't you try to make it yesterday?

Hi, my name is Mathijs Brand and I'm a Hippo business consultant / project manager. I've been working with customers and partners on Hippo projects for the last couple of years. I'll use this blog to tell you a bit about my experiences. Also I hope to show you some of the nice solutions we've come up with.

So maybe I was overreacting with the coffee. And I can understand why we're acting the way we are: it's harder for people to reduce options then just handing them out. Reducing options means making a choice yourself. If limiting options is hard for all kinds of features in the real world; it's even harder in the software world where options are virtually endless.

So why don't we give it a little effort? Try and define your audience. Find out what they are allowed to do or what they just don't want to see. Luckily - once you're done with the analysis - it's pretty straightforward to configure these options in Hippo CMS.

An example

Suppose you have a lot of very specific technical documents lying around. A few people are asking for them, but most don't find them very interesting. Just uploading all these documents to your website can easily end up in chaos like the picture below:

hmm... what button should I push?

Less is more

Let's say you want to do it right this time. Your editor wants to type a news item about cats and dogs. She doesn't want to see all these buttons and folders she can't do anything with. So give her a nice and quiet interface to give her more focus on the contents of the message.

In the above picture the editor just has a couple of options. In the news folder she can only add news items.

On the other side of the spectrum is your site administrator. He wants to be able to go through all of the advanced features managing your site. He likes to configure the rss feeds, widgets, overview pages, pdf's, portals and websites. He makes sure the news item automatically ends up in all of these media types. He likes to see how much memory his server has got and which java version is running. So hand him the buttons...

The administrator has lots of options.

The same kind of options can be given to people visiting your website. With metadata you can define which documents are interesting for which audience. You can also guide your audience through some questions and answers to find out their information needs. With a personal login you can achieve even more.

Conclusion

Hippo CMS gives you a lot of flexibility to limit choices. In the end reducing options gives your powerful web application the simplicity it needs. So pretty please with sugar on top - use these options - and let's get back to the real question:

Do you want the coffee with a touch of frost that gives a dreamy feeling on a lazy afternoon thanks to a selected combination of superbly engineered beans made by an ancient line of distinctive coffee engineers?

This was a repost, you can find the original post here: Limited choices, however there's not much sense in doing that, since you just read the same thing ;)

Jeroen Verberg (Hippo): Open source business model

Sun, 11 Apr 2010 20:56:56 +0000

The recent turmoil by Gartner's Brian Prentice blogpost and my upcoming trip to the Open Source Think Tank inspired me to pick up a

Lars Peters (Hippo): On Search Engine Optimization: Why canonical URLs matter

noreply@blogger.com (Lars Peters) — Tue, 06 Apr 2010 18:50:00 +0000

With the explosion of the amount of information organizations make accessible over the Internet, searchability and navigability are increasingly prominent on CMS wish lists. How do you structure site navigation when you have a bit more content than the average company?

Gov.nl

Consider the case of the Dutch national government: To provide convenient access to all governmental information citizens may need on a daily basis, it decided to bring information from 16 different ministries into one CMS.

To make centralization effective it needs to be paired with smart navigation. In larger contexts websites typically choose to provide more than one path to the same content. Technically this is achieved by tagging content instead of dropping it into fixed folders. Hippo CMS helps authors create these tags expediently and as of April 2010 citizens of the Netherlands have a number of centralized starting points to a large chunk of central government information (in Dutch):

Topic

Theme

Ministry / Department

Ministers

News

Canonical URLs

Flexible navigation may be great for users, it is not ideal for search engines. To offer compact results, search engines try to condense the list of URLs gathered from crawling through different paths to the same content piece. With a variety of algorithms a search engine then decides which URL is the leading road to the content.

Leaving this decision to the search engine is a risky choice. Various URLs for the same content compete with each other in the rankings and the site owner loses control over incoming links. For faceted search paths the number of navigation ways to a single piece of content is practically infinite. If not managed carefully, offering faceted paths could even lead to accidental blacklisting as the search engine might conclude you're trying to game its rating algorithm.

This is where canonical URLs come in. Tagging pages with a canonical URL helps a search engine understand that multiple URLs should be be listed only once. Hippo builds canonicalization into its CMS design, making sure that the dominant URL is provided to the search engine for each unique piece of content. This approach provides a combination of multiple flexible navigation paths, optimized search results and consistency for incoming links.

Example

Let's have a more detailed look at the government example. The following are just two sample URLs leading to an article about tougher laws for repeat DUIs:

http://www.rijksoverheid.nl/onderwerpen/alcohol/nieuws/2010/04/01/rijden-onder-invloed-harder-aangepakt.html

http://www.rijksoverheid.nl/nieuws/2010/04/01/rijden-onder-invloed-harder-aangepakt.html

In the source of both pages, invisible to the casual browser, a tag tells the search engine where to place this piece of content in its results.

link rel="canonical" href=http://www.rijksoverheid.nl/nieuws/2010/04/01/rijden-onder-invloed-harder-aangepakt.html"

And this is what Google returns when searching for a few of the article's keywords - Mission accomplished!

Rijden onder invloed harder aangepakt | Nieuwsbericht ...
1 april 2010 ... Rijden onder invloed harder aangepakt ... Ministerraad. Bel 0800-8051 voor vragen aan de Rijksoverheid ... Zoek binnen rijksoverheid.nl ...
www.rijksoverheid.nl/.../rijden-onder-invloed-harder-aangepakt.html - Cached

For a more in depth description how you can create canonical URLs with Hippo CMS check out our public wiki

Jeroen Reijn (Hippo): Metadata extraction with Apache Tika

noreply@blogger.com (Jeroen Reijn) — Mon, 05 Apr 2010 20:59:00 +0000

At Hippo I work with/for customers that have quite a lot of content. The projects I work on have content in the range of 5.000 to 500.000 document gathered in one content repository. This can be just textual content, but most of the time this is a variety of different content types. You might think of images, PDFs and Microsoft office document formats. By default Apache JackRabbit, the layer underneath Hippo Repository, can indexes this kind of content by using extractors, so that the information can be found within the Hippo CMS 7 search or from any application connected to the Hippo Repository which is performing a search on the content repository. Being able to search on content found within a file is interesting, but there is so much more that you can do with this kind of information.

Content metadata

Having all this content inside the repository is nice, but a certain piece of content uploaded to the repository can contain much more information then the file itself and sometimes this metadata is ignored in content management systems. As an example you might want to be able to see the number of pages of a PDF document inside your CMS or view the EXIF information of an image stored inside your content repository. There are a number of parser libraries out there that can extract information from a specific file format, but you can get quite lost. Within the ASF there is also a very nice toolkit called Apache Tika, which provides parsers for a lot of different file formats.

What is Apache Tika?

Apache Tika is a subproject of the Apache Lucene project and is a toolkit for extracting content and metadata from different kind of file formats. The content extraction logic is not located inside Tika itself, but Tika defines a standard API and makes use of existing libraries like POI and PDFBox for it's content extraction. While writing this post the current release of Tika is version 0.6 and the following file formats are already supported:

HyperText Markup Language
XML and derived formats
Microsoft Office document formats
OpenDocument Format
Portable Document Format
Electronic Publication Format
Rich Text Format
Compression and packaging formats
Text formats
Audio formats
Image formats
Video formats
Java class files and archives
The mbox format

As you can see this is already quite a lot. The team behind Tika is working hard on improving the current parser possibilities and adding more formats for the upcoming releases. Tika is actually already being used by a number of other Apache projects like JackRabbit and Solr. Now let's see how we can use Tika ourselves.

Getting started

I always work with Maven as my build system, so let's start of with a piece of pom.xml. First add the Tika parser dependency to our pom.xml.

<dependency>
  <groupId>org.apache.tika</groupId>
  <artifactId>tika-parsers</artifactId>
  <version>0.6</version>
</dependency>

By depending on tika-parsers Maven will automatically gather the required parser libraries, which are needed to parse certain file formats. Since my Java code example will be based on a unit test, we will also need to add JUnit as a dependency to our pom.xml.

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.7</version>
</dependency>

In this post I want to see what kind of EXIF information can be retrieved from an image by using Tika. One of my hobbies is photography and therefor I have tons of images, which contain a lot of metadata about for instance the ISO speed or dimensions of an image. Now let's write some actual code to see how Tika works.

The actual code

As I mentioned before, my example code is written as a JUnit test. If you are not familiar with writing tests or JUnit itself please have a look at the JUnit website.
To be able to run this test, I've added one of my images on the test classpath, so my test class will be able to find the image resource. The following piece of code shows my entire test class.

public class ImageMetaDataTest {

    private static final String fileName = "IMG_2659.JPG";

    private Tika tika;
    private InputStream stream;

    @Before
    public void setUp() {
        tika = new Tika();
        stream = this.getClass().getResourceAsStream(fileName);
    }

    @Test
    public void testImageMetadataCameraModel() throws IOException, SAXException, 
            TikaException {

        Metadata metadata = new Metadata();
        ContentHandler handler = new DefaultHandler();
        Parser parser = new JpegParser();
        ParseContext context = new ParseContext();

        String mimeType = tika.detect(stream);
        metadata.set(Metadata.CONTENT_TYPE, mimeType);

        parser.parse(stream,handler,metadata,context);
        assertTrue("The expected Model is not correct", 
                metadata.get("Model").equals("Canon EOS 350D DIGITAL"));
    }

    @After
    public void close() throws IOException {
        if(stream!=null) {
            stream.close();
        }
    }

}

As you can see the code is quite small. The most important part of the above code example is using the JpegParser to parse the .JPG file and the creation of the Metadata object with the appropriate information.
I think this simple test case shows you how easy to use the Tika API is. Of course in the above test case I only test for the current Camera Model, but the Metadata object holds much more information then just that.

Viewing all the fields found in the metadata of the image can be achieved quite easily by using for instance the following method.

private void listAvailableMetaDataFields(final Metadata metadata) {
  for(int i = 0; i <metadata.names().length; i++) {
    String name = metadata.names()[i];
    System.out.println(name + " : " + metadata.get(name));
  }
}

The output of this method can be like:


Easy Shooting Mode : Manual
Image Type : Canon EOS 350D DIGITAL
Model : Canon EOS 350D DIGITAL
Metering Mode : Evaluative
Quality : Fine
Shutter/Auto Exposure-lock Buttons : AF/AE lock
ISO Speed Ratings : 400

It's as easy as that.

Looking ahead

I'm currently looking for possibilities of integrating Apache Tika into Hippo CMS 7, to enhance the system with much more metadata then there currently is available in the system. I think this can become quite a powerful addition in combination with the facetted navigation feature introduced in Hippo CMS 7.3. I've already started working on some code, which I hope to provide as a patch in the near future. I hope to provide an update in the near future.

Arje Cahn (Hippo): The Dutch national government has a brand new website

Wed, 31 Mar 2010 09:01:19 +0000

News from the Dutch open source camp:

"On March 31, 2010, the first version of www.rijksoverheid.nl went live. This common website for all government ministries will make the central government more recognizable and accessible." (source:

Tjeerd D. Brenninkmeijer (Hippo): OSBC 2010: open source is much more than just a money saver

Wed, 24 Mar 2010 07:01:35 +0000

Last week, for the second consecutive year, Hippo sponsored the OSBC - Where Open Source meets Business in downtown San Francisco. Living up to its reputation as the most business oriented open source conference out there, the OSBC offered a chance to interact with other business leaders of open source companies and discuss how we're able to combine great free for all software with the payroll of a professional organization. At the second OSBC since Lehman Brothers, this was a good moment to reconfirm what was tentatively said last year: Companies see Open Source technologies as a great way to control cost, and while the rest of IT struggled, Open Source companies continued to grow at a rapid pace. However, Open Source as a money savings device is no longer a hard sell. It has become such a popular theme, that other advantages don't get the attention they deserve. Clearly part of the mission of the OSBC is to set the record straight and focus on the open source method and technologies as a source of competitive advantage Meanwhile, in the exhibitor hall, the Hippo team was showing off the latest demos of Hippo CMS 7.3 and a pre release version of Hippo Portal 2, due to be released before the Summer. As an attention grabber, the demos met some stiff competition from the other side of the table where orange hippos were stacked up. The OSBC was just the first in a row of US conferences for Hippo to sponsor this year. If you have a chance to attend, find us the coming months at CMSExpo in Chicago, Web2.0 in San Franciso, JBoye in Philadelphia and the Gilbane conference in San Francisco. Keep an eye out for more events to be announced on our website.

Arje Cahn (Hippo): Hippo CMS 7.4 preview: version compare

Fri, 19 Mar 2010 16:51:03 +0000

This is work in progress - but I got so excited when I saw it working that I couldn't resist turning it into a quick Friday afternoon demo video. This functionality will be released in Hippo CMS 7.4 which is scheduled for June, so I'm afraid I'm going to have to ask you for a bit of patience - but at least you'll have something to look out for :)

Suppose Joe is our author and he's working on a new article that he wants to push live. He requests publication, and sends the article off to his editor, Jane, for review.

I'm logging in as Jane now, and I can see the request that she got. Jane is fine with the article, so she pushes it live.

A couple of days later, Joe the author comes in again, and he changes some of that content he wrote before. And he requests publication again.

Jane logs in, sees the requests and wonders: What's new?

Hold it here - I need to explain some background. Of course we have versioning and history and all that. Every CMS does. But how easy is it to get to that comparison view? How many clicks do you have to perform to compare the current version of the document with the one that's online right now? And what kind of a view does it give you? How often do you do this? And if it would be *super* easy, wouldn't you just want to see that comparison view all the time? All in all, you're working with a team of editors in the same content pool and you need that contextual information about what's going on in the system, and who did what, where.

So that's what we did. We made it uber-super easy!

Click it - and there you go! That's what's new. Hippo CMS shows you the comparison view right there when you view the article. That is, when something has changed. It simply shows you the difference between the current version of the document and the one live on the website. How useful is that? If you need more information - you can of course dive into the version history, but this simple comparison view is probably all you need.

Again - we hope to be releasing this with Hippo CMS 7.4 in June, so hold tight.

In the meantime, let me know what you think - feedback is very much appreciated.

Arje Cahn (Hippo): What's wrong with portals?

Thu, 11 Mar 2010 08:50:36 +0000

This post clearly describes the problem that I see with all current portal implementations: they treat content as “just another application running inside a portlet”. When we stick to this paradigm, it will kill Portal. Content behaves very different from legacy apps, and simply offering a contextually disconnected content management portlet is not enough. Content deals with semantics and relationships: users expect a portal to be smart enough to render content that is related to the apps they see right there on their screen, and they expect content to be reused across different sections in a portal, wherever that makes sense. Not to mention user-generated content.

Wikis gave users the possibility to quickly create and collaborate on content, but they don't come with the visual application integration that Portals offer. And they lacked the degree of control of a decent content management system. Integrating Portal and CMS is more than just adding a 'content portlet'. Adding an in-context application to a Wiki page would be more in line with how users think. They navigate your online consumer portal, find a page that answers their question and then they want to act on it directly. The FAQ page on “How to request a new password” should render the “New password” portlet in-line with the article. This is just an example - but this is clearly the direction Wikis are heading as they're maturing towards something that resembles an integration of Portal and CMS, and they're leaving traditional Portals way behind.

Portal vendors need to move towards the Content Driven Portal. At least, this is direction we've chosen to go with Hippo Portal. Users want URLs that make sense, that say something about the information that can be found on a page. They want to pop the URL of a portal page into an email and send it to someone else and it should just work - within the appropriate security constraints of course. What applications are shown on the portal page should follow the context, not the other way around. People got used to this concept during the Wiki revolution, and they'll never want to go back.

Tjeerd D. Brenninkmeijer (Hippo): Five golden rings, four golden Hippos and one platinum Hippo

Fri, 26 Feb 2010 14:18:51 +0000

Today we will leave the office by taxi to a secret 'kart' location where we will be treated to some (non alcoholic) drinks, some "bittergarnituur" and a presentation by Stefan. Later on we will get a short introduction in how a kart works (probably only useful for myself) and do a training lap. Three races will follow after the best classed drivers will compete in a grand finale! The best driver will get a bottle of (very cheap) champagne after which the barbecue will be lit. We'll have food, beer and laughs until ~8 after which the official programme is over. We'll see what happens afterwards. And of course the one true winner of the evening will receive the Golden Hippo! A golden what? A golden Hippo? Yes! a golden Hippo! Not just one, they're like Pokemon, gotta catch'em all! One can 'catch' (i.e. win) a golden Hippo by popular vote (how open source awards should be won). Once every quarter each member of our professional services department can be voted. Clients, Hippo partners & colleagues can vote the 'best' Hippo consultant (and yes, we disabled the option that you can vote for yourself or your chief ;-) Just like today the golden Hippo will be awarded on a team event (organized by our very own event committee) and it is accompanied with a nice little bonus. This bonus, while nice, should be publicly disregarded by the receiver as insignificant compared to the true honour of receiving a gold coated piece of wood with a rubber hippo on top! And our partridge in a pear tree? Replaced by a single platinum Hippo which is awarded at the end of each year to the true master of the Golden Hippos. This should be considered as an even more important cheap statue :-)

Jeroen Reijn (Hippo): Jboss ModeShape: A federating JCR repository

noreply@blogger.com (Jeroen Reijn) — Thu, 04 Feb 2010 15:27:00 +0000

Some interesting stuff is happing in the JCR community. With Apache Jackrabbit 2.0.0 out (with JCR 2.0) and an interesting project called Jboss ModeShape almost reaching it's final 1.0 release. ModeShape recently came to my attention and it seems an interesting project. In this post I will give a short introduction of ModeShape and it's features.

What's ModeShape?

ModeShape is a Java Content Repository implementation which will support both JSR-170 and JSR-283. It's not trying to be just another isolated content repository, but a repository with a strong focus on content federation. In other words: ModeShape's main goal is to provide a single JCR interface for accessing and searching content coming from different back-end systems. These systems can even be of different sorts. You might think of a ModeShape repository containing information from a relation database, a file system and perhaps even another Java content repository like for instance Hippo CMS 7's content repository. You can configure these sources of information with the help of ModeShapes connector framework.

Connectors

One of ModeShape's key concepts is the concept of connectors. A connector will allow you to connect to a certain type of back-end system and transparently expose the information inside the ModeShape repository. In the current 1.0.0 beta release there are already a couple of out of the box connectors available:

In-Memory Connector
File System Connector
JPA Connector
Federation Connector
Subversion Connector
JBoss Cache Connector
Infinispan Connector
JDBC Metadata Connector

That's already quite a few, but for the upcoming release they also have plans for expanding the set of connectors with for instance a JCR connector, which I find quite interesting myself, because that would allow you to expose other JCR implementations like Hippo CMS 7 (Apache JackRabbit) in combination with other systems through one JCR interface.

There are many other content solutions out there, so if you can't find a connector that suits your need, you can of course write one yourself and perhaps donate it to the ModeShape project.

Sequencers

One of ModeShapes other interesting features is the concept of sequencers. With sequencers you can gather additional information from a certain item inside the repository and store that extracted information in the repository. ModeShape has quite a few sequencers out of the box:

Compact Node Type (CND) Sequencer
XML Document Sequencer
ZIP File Sequencer
Microsoft Office Document Sequencer
Java Source File Sequencer
Java Class File Sequencer
Image Sequencer
MP3 Sequencer
DDL File Sequencer
Text Sequencers

The example below is of the ImageSequencer, which can gather information from certain types of images stored inside the repository. The ImageMetaDataSequencer is used here to extract metadata like size, dimensions and so on from the image if they have one of the specified extensions and the extracted information is stored somewhere else inside the repository.

JcrConfiguration config = ...
config.sequencer("Image Sequencer")
.usingClass("org.modeshape.sequencer.image.ImageMetadataSequencer")
.loadedFromClasspath()
.setDescription("Sequences image files to extract the characteristics of the image")
.sequencingFrom("//(*.(jpg|jpeg|gif|bmp|psd)[*])/jcr:content[@jcr:data]")
.andOutputtingTo("/images/$1");

Conclusion

With other mature JCR implementations out there I think ModeShapes strongest point is it's focus on content federation. Providing a single JCR interface for content stored in different systems is a great initiative, because the JCR API is quite easy to learn and to use. I see a bright future for ModeShape, since companies are sharing more and more in-house information on the web these days. I myself will try to keep a close eye on ModeShape and see how it evolves.

Lars Peters (Hippo): Why WCM/Portal convergence is a good thing

noreply@blogger.com (Lars Peters) — Wed, 27 Jan 2010 01:01:11 +0000

Stephen Powers' blogpost on convergence between WCM and Portal sparked a nice little controversy about the alleged trade-off between integration and separation of concerns. It ain't necessarily so: If integration is done right, the trade-off does not need to be there at all.

Convergence is a two way street. From the WCM perspective we like to think of Portals as a way to offer 'self service', personalization, security and integration with other applications / widgets / iframes and the like. From the Portal perspective we need WCM to provide tools to work with our portal content that does not reside in other applications.

Both are, of course, nothing new. Neither is the fact that vendors (Hippo with Hippo CMS and Apache Jetspeed Portal is the open source example) have been offering integrated portal offerings for a number of years. Given the challenges and costs involved in true integration, it clearly makes sense to offer integrated solutions as to keep such projects manageable. And who can better ensure integration is done right than the vendor itself?

New in Stephen's post is the fact that he, or rather IBM, sees the package of WCM & Portal becoming such a common combination that distinguishing the two markets would no longer be meaningful. This does not mean that WCM and Portals will become an undistinguishable mesh (or mess?) with the risk of losing all we gained from separating content from the presentation layer in the first place.

It does mean, just like before, that buyers should be careful not to select a package that restricts their choice in where and how to manage and publish their content. It also means that buyers should be critical when making decisions about such things as collaboration platforms. Collaboration systems put in place today, may be with us for many years to come. Where does the content reside? Can it be accessed, altered, integrated in other applications? What about the source code? Remember Lotus Notes?

For maximum flexibility and future readiness in purchasing an integrated WCM & Portal, there are four basic questions to ask:

1. Can the WCM system stand on its own? Would you buy it for its WCM functionality?

2. Can the Portal stand on its own? Would you buy it for its Portal functionality?

3. Are the two really integrated? Integrated user management, security, administration, URL mapping, ease of development etc.

4. Is it Open Source (eg, are you free to use and change the software as you wish)?

David Taylor (Hippo): Jetspeed UI in 2.2.1

noreply@blogger.com (DST) — Thu, 14 Jan 2010 04:01:16 +0000

With this blog post, I introduce the new Jetspeed portal user interface we are developing for the upcoming release of version 2.2.1. For the past several years, the Apache Jetspeed Portal has had two user interfaces:

1. The Portal Pipeline, a server-side, servlet based aggregation engine. The server-side rendering engine was and still is the most common user interface for Jetspeed portals. It has progressed over the years, including the addition of nice features like a multi-threaded aggregation engine, rendering each portlet in parallel on its own thread.

2. The Desktop Pipeline, a client-side, Javascript based aggregation engine. The client-side rendering engine was not the default, and didn't get as much attention as the server-side. That said, I think the desktop pipeline had much more interesting features, with Ajax rendering pipelines serving portlet content to handle parallel rendering requests from within the browser. The desktop pipeline, even though it ran in the browser, still supported the Java Portlet API, adhering to the requirements of action and render phases. It also had some interesting features including drag and drop moving of portlets in either grid or detached mode, and resizing the portlets and layouts.

With version 2.2.1 (still unreleased), we are working on a single rendering engine sharing the same pipeline and code base. This engine can be configured to render portlets on the server-side or client-side. We call this new rendering engine "Jetui", since the client-side code is based on the YUI Javascript library. Jetui already supports many of the drag and drop customization features of the Desktop pipeline, with the addition of several new features. Two interesting new additions are the toolbars: a Page and Space Navigator and a Toolbox.

In this blog I will introduce the Jetspeed Toolbox. The Toolbox is designed to make user customizations very easy in just one click. The toolbox contains three panels:

- Portlet Selector
- Layouts
- Themes

The Portlet Selector can be docked to the left or right side of the page, or it can float freely on top of the page. Portlets can be searched for using this tool, as all portlet metadata is automatically indexed in the portlet registry. Additionally, portlets can be categorized and filtered based on categories (see the drop down list). One click addition of portlets is now possible without ever leaving the page being customized. Portlets are also filtered by secure access. Only portlets that are configured to be viewable to the current user are displayed in the Jetspeed Toolbox.

An interesting new feature is portlet preview mode:

Selecting the theme for the current page or space is as easy as selecting the theme tab and then clicking on the theme. Jetspeed introduces several new themes in 2.2.1:

Page layouts, selected from the Layout tab, provide several default layouts (with more coming).

We are working on integrating the W3C Widgets alongside Java Portlets. Like portlets, widgets will be available for searching and adding from the Jetspeed Toolbar. I will discuss Widgets more in an upcoming blog.

In an upcoming blog, I will talk more about how to use templates to configure tools across pages...

Arje Cahn (Hippo): 2010: the year the E-Reader will become the content managers’ favorite productivity tool

Thu, 31 Dec 2009 11:43:41 +0000

Flipping through my usability notes, I noticed one of our Hippo CMS users mentioned the following about proof-reading:

“There is no printing facility for content in Hippo CMS so everything has to be done on screen. Ev

Jeroen Reijn (Hippo): Content mangement and the semantic web

noreply@blogger.com (Jeroen Reijn) — Thu, 17 Dec 2009 10:43:00 +0000

I came across the term 'semantic web' a couple of years ago, when one of the original creators of Apache Cocoon went of to work on the SIMILE Project at MIT. I didn't pay much attention to the concept of 'semantic web' back then, because I just started learning Apache Cocoon and still had a lot to learn.
But over the last couple of months I've been doing some research on the currently available standards for providing semantic data on the web with a strong focus on RDFa.

Content management

Working at Hippo, a CMS vendor based in the Netherlands & USA, makes me think in content and publishing strategies. Publishing information to the web is one of our core businesses, but I've learned over the last couple of month we can enrich our publishing platform even more by providing semantic data. I started my journey by looking around if other CMS vendors are paying attention to semantic web standards. I noticed that only a few of the enormous amount of content management vendors actually put effort in providing semantic web functionalities for their end-users. I think that's a shame, because enrich your pages a lot.
This post should give you an insight on how you could create a website with embedded meta data (with Hippo), but let's first start with some basics.

What's the idea behind the semantic web?

The current web is very well suited for being read by people like you and me. Computers however can only analyze the words on a page, but can not see the semantics of a piece of information on that specific page, that we as people do see.
If you would allow the information on you page to be machine-readable, the computer would be able to analyze your page and extract much more information from it then just being a piece of text. That's where semantic web standards can help out.
Standards for providing semantic data on the web are not new and some of them have already been available for quite some time. Probably the two most well known are: RDF and Microformats. However recently RDFa has been getting a lot of attention by Google, Yahoo and now also the UK government.

What is RDFa?

RDFa is short for “Resource Description Framework in attributes”. This sounds a bit descriptive, but it means that RDFa provides a set of XHTML attributes, which in their turn provide a way of translating visual data on a page into machine-readable hints. So let's take a look at an example of how a simple web page is currently structured.

<html>
  <body>
    <h1>Content management and the semantic web</h1>
    <h2>Jeroen Reijn</h2>
    <p>some information</p>
  </body>
</html>

As you can see in the above XHTML fragment, we have a page with a title, a subtitle and a small snippet of text inside the body of the page. By rendering this HTML fragment in the browser the visitor of this page will recognize this piece of text as being the title and author of the current article on the page. A machine however would need a bit more information to be sure the content can be identified as a title and author. That's where RDFa can help out. By using vocabularies, you can give meaning to specific pieces of content on a page.
Let's see what the above XHTML fragment would look like if we would use RDFa.

<html>
  <body xmlns:dc="http://purl.org/dc/elements/1.1/"> 
    <h1 property="dc:title">Content management and the semantic web</h1>
    <h2 property="dc:creator">Jeroen Reijn</h2>
    <p>some information</p>
  </body>
</html>

As shown in the example, the Dublin Core vocabulary is added to the page first. This is important to be able to use the properties inside the vocabulary later on. Once the vocabulary is in place, we can give meaning to fragments on the page. In the HTML fragment above the h1 is marked as the Dublin Core title attribute and the h2 as the Dublin Core creator attribute. With these properties in place a machine, like a search engine crawler, can now also store this as additional meta data of the page.
One of the main advantages of RDFa is that your content can processed in a more efficient way, which in turn can make your page rank higher then it might have been before.
Big search engines like Google and Yahoo already scan your website for RDFa embedded information, so why not use it?

How to use RDFa in your (hippo) website?

Hippo CMS is a content (centered) management system and it differs from other CMS's in such a way that the information inside the Hippo CMS content repository is not stored or identified as pages, but rather as content. In most cases even reusable content. To be more precise: information stored inside the content repository is stored as JCR nodes and/or properties.
Since the data is just content and not bound to any front-end technology, you can either publish it as XML, (X)HTML with some help from the Hippo Site Toolkit (HST) or any other format you might like.
Now let's take the above HTML fragment as an example and let's see what this would look like on a content level. One of the most important things to mention here is that a JCR repository has the concept of nodetype definitions in which you can configure what your data model looks like. You could compare it with for instance a XML Schema or DTD for a piece of XML, but then for the nodes and properties available in a JCR repository.

Let's first start with our content definition or in content management terms the document type. We will need three fields:

Title
Author
Body (rich-text field)

If you would create a document type with the Hippo CMS template editor, the resulting nodetype definition will end up looking like this:


<'myproject'='http://www.myproject.org/nt/myproject/1.0'>
<'hippostd'='http://www.onehippo.org/jcr/hippostd/nt/2.0'>
<'hippo'='http://www.onehippo.org/jcr/hippo/nt/2.0'>

[myproject:text] > hippostd:publishable, hippostd:publishableSummary, hippo:document
- myproject:title (string)
- myproject:author (string)
+ myproject:body (hippostd:html)

As you can see all three fields are available and can be used later on by any client that can read from the Java content repository. To be able to render this type of information as XHTML, we will be using the Hippo Site Toolkit. The Hippo Site Toolkit uses the concept of mapping JCR nodes to simple Java beans, to be able to have an easier development cycle without having to learn the entire JCR API.

A Java bean representation of the JCR 'myproject:text' nodetype will look like this:

import org.hippoecm.hst.content.beans.Node; 

import org.hippoecm.hst.content.beans.standard.HippoDocument;
import org.hippoecm.hst.content.beans.standard.HippoHtml;


@Node(jcrType="myproject:text")
public class TextBean extends HippoDocument{

    public String getTitle() {
        return getProperty("myproject:title");
    }
    
    public String getAuthor() {
        return getProperty("myproject:author");
    }

    public HippoHtml getBody(){
        return getHippoHtml("myproject:body");
    }

}

As you can see the Java bean is quite straight forward and easy to read.
Now if we want to render the information on a webpage, we can use for instance JSP's with expression language to get the information from the Java bean. The JSP needed for outputting the RDFa enabled webpage can be as simple as this:

<%@ page language="java" %>
<%@ taglib uri="http://www.hippoecm.org/jsp/hst/core" prefix='hst'%>
<html>
  <body xmlns:dc="http://purl.org/dc/elements/1.1/"> 
    <h1 property="dc:title">${document.title}</h1>
    <h2 property="dc:creator">${document.author}</h2>
    <hst:html hippohtml="${document.body}"/>
  </body>
</html>

As you can see it's that easy to use RDFa inside your website if you have a template independent CMS like Hippo.

It gets even better

Using RDFa for simple text can already be a great improvement for you website, but support for other RDFa vocabularies is added on a regular basis. Google recently announced support for RDFa enabled pages with videos (or media) on them. You can provide extra information for your media files to the Google crawler, like the url to the thumbnail that belongs to your video, which can be presented when your video is found as one of the results in a search performed at Google. The possibilities are enormous, so I can see a lot of good things coming from using RDFa in the near future.

I think the role that content management systems can have for RDFa should not be underestimated, since most website these days are backed by some sort of content management system.

For more information on RDFa see:

RDFa for HTML authors, by Steven Pemberton
RDFa.info - A site containing news about RDFa
Google supporting FaceBook Share and RDFa for videos

Jasha Joachimsthal (Hippo): Generate RSS in JSP? Set the locale!

Jasha Joachimsthal — Thu, 10 Dec 2009 08:55:00 +0000

The RSS pubDate fields contain dates in a format that may be human readable, but not very handy in a programmer's point of view. According to the RSS specification the date must conform to the RFC822 specification. A typical RSS snippet looks like:

<item>
  <title>Generate RSS in JSP? Set the locale!</title>
  <description><p>Description of the feed item</p></description>
  <link>http://blog.jasha.eu/2009/12/generate-rss-in-jsp-set-locale.html</link>
  <guid>http://blog.jasha.eu/2009/12/generate-rss-in-jsp-set-locale.html</guid>
  <pubDate>Wed, 10 Dec 2009 09:55:00 +0100</pubDate>
</item>

An easy way to generate this from JSP is using the fmt library from JSTL.

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<item>
  <title>${item.title}</title>
  <description>
    <![CDATA[<hst:html hippohtml="${item.html}"/>]]>
  </description>
  <link>${link}</link>
  <guid>${link}</guid>
  <pubDate>
    <fmt:formatDate value="${item.date.time}" pattern="EE, dd MMM yyyy HH:mm:ss Z"/>
  </pubDate>
</item>

This seems to look good when you request the RSS feed from your browser. However when you request the same feed from a Java (ROME), a request generator (Fiddler) or just use wget the format of the pubDate field is invalid. It returns "Wed Dec 10 09:55:00 CET 2009" instead of "Wed, 10 Dec 2009 09:55:00 +0100" as value of pubDate. What happened?

Your browser sends a header "Accept-Language" with, hopefully, "en-US" as first value. The JSTL library uses the en-US locale to format the date and the feed gets parsed correctly. The other tools don't send this header and the programmer did not specify a locale for fmt. fmt does not know how to format the date and returns a "Date.getString();".

A workaround for you as requester of the feed is to manually add the "Accept-Language" header to the request with value "en-US". For the JSP developer: the date format for RSS should always be "en_US". Just add this line to your JSP:

<fmt:setLocale value="en_US"/>

Tjeerd D. Brenninkmeijer (Hippo): A short recap of Forge Friday: October 30th

Mon, 16 Nov 2009 11:25:08 +0000

Everyone was invited at the Hippo office's in Amsterdam or San Francisco to participate in the creation of cool projects. Any idea was welcome, as long as it was Hippo related (and could therefore be posted

David Taylor (Hippo): Apachecon, Oakland

noreply@blogger.com (DST) — Thu, 05 Nov 2009 02:01:00 +0000

I will be presenting at Apachecon in Oakland tomorrow at 9 AM.

http://www.eu.apachecon.com/c/acus2009/sessions/282

The presentation is less than an hour, introducing new direction in the Jetspeed open source portal, integrating with the Apache Jackrabbit project

Arje Cahn (Hippo): ApacheCon US 09 Evening Meet-ups - Free for all

Mon, 26 Oct 2009 13:01:18 +0000

Monday 2nd, Tuesday 3rd and Thursday 5th of November
Oakland, CA
Content Tech, Hadoop, Lucene, NoSql, OSGi/Felix, SocialAndWidgets, Subversion, Tomcat, Traffic Server Podling, WebCrawlers, WebServices

Join us for a third year of Apache Meetups! Users, committers, managers and

Jasha Joachimsthal (Hippo): Generate the robots.txt from Hippo CMS

Jasha Joachimsthal — Sun, 25 Oct 2009 14:01:10 +0000

The robots.txt is a response from your website that is unimportant for your human visitors but very important for search engine crawlers. That's why we created a Hippo CMS / Hippo Site Toolkit (HST) plugin to manage the robots.txt in the CMS and return the proper output.

The plugin comes with an out of the box document type to manage the parts of the site that are disallowed to crawl for search robots. There's usually one configuration for all crawlers but if you want, you can add multiple configurations per crawler.

In the first screenshot all crawlers should skip "/donotindex/" and "/search/", only "Googlebot" should ignore /hide/for/googlebot and the non existing "EvilBot" is kindly requested not to index the site at all.

Generating the response is mostly configuring the HST response for the request for "robots.txt". The plugin comes with a demo project and documentation how to configure the plugin for your existing project.

In the second screenshot you see the response by the HST for the "robots.txt" request. The HST returns a plain text response with all the fields we've configured in the CMS.

Arje Cahn (Hippo): Hippo Forge Friday: October 30

Thu, 22 Oct 2009 10:08:02 +0000

Get your hands dirty with Hippo, the open source Java CMS and Portal framework that everybody talks about. Join us for this free Hippo Forge Friday plugfest! We've scheduled an afternoon of free flow Hippo coding on Friday, October 30 in our offices in Amsterdam and San Francisco.

Build a CMS plugin, a portlet, a repository addon, an HST component, or something else that you think is cool enough to turn into an open source Hippo Forge project. The core Hippo developers will be there to help build the Hippo component you always dreamed of! A Google Analytics plugin, an image resizer, a Jira portlet, a Lightbox HST Component, you name it. You can sign up here.

Whether you're an experienced Hippo hacker or a complete newbie, come join us for some proper coding fun, beers and food. If you don't know where to start - we'll help you get on track :)

We'll spend half a day on pure hacking galore, a big BBQ, beers, and of course: geeky prizes! Bring your laptop and we'll take care of the rest.

What: First international Hippo Forge Friday

When: October 30th from 14.00 until 21.00

Where:
Where:
Hippo Office Amsterdam: Oosteinde 11, 1017 WT Amsterdam
Hippo Office San Francisco: 185 H Street, Suite B, Petaluma, CA 94952

Why: A fast paced, hands-on introduction to Hippo. Get to know Hippo by writing plug-ins, HST components, portlets, and all things Hippo-like. Gain eternal fame by winning one of our prestigious prizes!

Who: All Java developers and web enthousiasts.

Registration: Make sure you sign up early by filling in the Forge Friday sign up form.
.

More info: Read Tjeerd's blogpost about the last Forge Friday and keep an eye on the Wiki page.

Tjeerd D. Brenninkmeijer (Hippo): The Hippo hunting season has been opened!

Wed, 07 Oct 2009 16:23:13 +0000

Last week I was in Paris for the Open Source World Forum. And looking at my travel plans for the upcoming months I noticed that the conference season has started again. For us this means driving around with big boxes of orange-anti-stress-hippos, lots of

Lars Peters (Hippo): Do it yourself software

noreply@blogger.com (Lars Peters) — Tue, 22 Sep 2009 03:54:00 +0000

Recently I refreshed my memory on a company my friend Alef Arendsen, then at SpringSource, pointed out to me. Charles Simonyi of Intentional writes that “all too often the knowledge and insights gained during the development disappear into the details of the code”.

Although Intentional as a company has been around since 2002, and its ideas date back to the 90’s, this is still very much where business software is at today. The need for specialized engineers to get involved to build applications or websites, comes at a loss of direct influence and knowledge about the things that you need to build. Companies that are able to successfully bridge this gap, can produce stunningly usable software that others just don’t seem to get right: Google and Apple are the obvious examples.

In this light Content Management Systems have always been about putting direct control back into the hands of business. When trying to create web pages, back in the early/mid ‘90s, I had to teach myself a bit of HTML for even the simplest piece of green text on a black background. With business software this is no different. While years back for every 1 or 0 you needed a team of programmers, now many of us with simple development skills can create very complex and powerful applications.

Most of these developments stop short of one final step: new technology has empowered the developer, but you still need programming skills to get sophisticated enterprise applications up and running. The business users or ‘lay programmers’ as Martin Fowler calls them here, remain dependent on the IT community to realize their ideas. Hence business users stretch the boundaries of the tools they control: multi billion dollar projects with 1000s of people are entirely managed with cleverly designed spreadsheets.

The first step in CMS development was to take the developers out of the loop in changing content on the website. With this 'Do-it-yourself' software a company did not only dramatically reduce the cost of maintenance, it also enabled business users to control the content directly. This in turn solved many of the translation problems on early websites. With a CMS it was immediately clear what a text would look like online. Text could be correctly fitted and the author could place pictures exactly where he wanted.

Today even the simplest CMS has solved this problem and it is time to push the bar a bit higher: giving business the power to change and build complex websites integrating existing applications without IT support: so it does not require a project proposal and 4 months queuing time to get a new site live. And yes, it would be nice if it could all run on an invisible internal or external cloud infrastructure, so you would not have to worry about plugging in an extra server or getting the backup hooked up.

The benefits are clear: No more ridiculously detailed requirement sheets, no more blame game when the results don’t meet expectations in spite of this effort, and much, much shorter cycles – removing an entire layer of ‘friction’ between customer and producer.

None of this is new – but in practice many challenges remain. While those in the know seem to be able to develop great looking, complex integrated sites in a matter of days or weeks; the average business user still fumbles with his Excel spreadsheet. And while the developer community has largely embraced the open source development model, participation of business users is notably low. With business users largely sidelined, there is a permanent danger for open source projects to lose track of the ‘business intent’ of a project. In projects where the engineers and business end users are one and the same, this danger is relatively low, but with any software that moves up the enterprise ladder, the dangers of a disconnect grow. On the bright side: if successfully tackled there seems to be a terrific opportunity for open source companies to involve more business users in their projects.

Ideally the end result of such a project is not only a CMS driven website or a content driven portal, but a system that allows users to use this as a starting point, with easy to use interfaces for creating additional websites and/or portals.

Here are a few things we do at Hippo make it easier for our partners and customers to build such environments:

Provide direct and user friendly access to administrative interfaces; eg, drag and drop Portlet selector for Jetspeed Portal 2
Give access to functionality previously only available to programmers through a user friendly UI: eg, Nested Template Picker, Site control functions in CMS 7 or space creation in Jetspeed Portal 2.
Involve end-users in ongoing road map meetings, not just during the requirement / delivery phase
And of-course: Develop products with a keen eye on keeping things clean and nimble for the daily user

So we're not quite at the full realization of Simonyi’s lofty goals yet, but rapid development environments and the rise of cloud infrastructures provide an opportunity to involve business users in different ways than before. Companies definitely seem eager to embrace it.

Jeroen Reijn (Hippo): Apache Cocoon and Javascript minification

noreply@blogger.com (Jeroen Reijn) — Tue, 15 Sep 2009 20:01:17 +0000

A couple of days ago somebody on the Apache Cocoon user list send a message to the mailing-list about on the fly minification of for instance Javascript files. This topic has been quite popular over the past years, since web application have become richer and Javascript files have become larger.

The ideal situation would be to compres your static files (CSS or Javascript) at build time, so this will not cost you any processing power, when your application is already running. I myself quite often use the Maven 2 YUI compressor plugin while building my projects, but in case you can't use this plugin you could think about a different solution. Since I've been using Cocoon for over more then 5 years, I thought I gave it another try and write a nice Cocoon reader that does this minification for you.

There are multiple minification and obfuscation frameworks out there. One has a greater compression ratio then the other, but for me the most well know ones are probably:

Dojo Shrinksafe - Rhino based compressor from the Dojo Toolkit
YUI Compressor - Rhino based compressor by Yahoo
JSMin - a whitespace compressor by Douglas Crockford

Since Apache Cocoon comes with a version of Rhino and both #1 and #2 have their own version of Rhino included, this could end up having nasty conflicts because of two different versions of the library on the same classpath. Therefore I chose to write a reader based on JSMin, which does a lot of whitespace compression for you.

The implementation of this reader was quite simple and if you're interested, you can get the source here. Do keep in mind that you will have to have the JSMin.java file also on the classpath, otherwise it wil not work.

Tjeerd D. Brenninkmeijer (Hippo): Block your agenda for the international Hippo Forge Friday on the 30th of October

Wed, 26 Aug 2009 14:18:36 +0000

Forge Friday sounds cool, but what is it? The goal for everyone, so all developers, technical support engineers, architects, sys admins, hackers etc. is to build a CMS plugin, a portlet, a repository addon, a HST component, or something else that you think is cool enough to turn into a Hippo Forge project (and win the big prize(s)! ;-). On Friday the 14th of August Hippo had its first international Forge Friday, a joint effort between the offices in San Francisco and Amsterdam. We had a full afternoon and evening of pure hacking, a big BBQ, beers, and of course: geeky prizes. Besides building forge projects the overall goal is also to share knowledge between all the different people in our offices in Amsterdam and San Francisco and do something different for a day. So build a portlet when you've been building HST components all of your life, or build a CMS plugin when you've been building portlets since the Americans set foot on the moon. For this special occasion we built a brand new Forge Portal (a mashup of Hippo CMS, Jetspeed & Google ideas). On this Portal employees could submit ideas of what they think would be useful to create or (also important) fun to work on. During an intensive and fairly warm afternoon in our brand new office space you could feel the creativity and energy flowing. Groups were formed in such a way that teams were mixed as much as possible to get a maximum cross-over of knowledge and skills. And the results were amazing. Not only did it seem possible to create a forge project in less then a day, it was even possible to make it work and demonstrate it to the rest of the colleagues. There were no restrictions to the projects chosen, but there were some for the presentations: - Whatever you build has to be targeted towards the latest stable or Trunk versions of Hippo CMS 7, Jetspeed 2.2, HST 2, Hippo Repository 2, or a combination; - Your code has to be ready at 20:00, and demoed live, in a 2 minute elevator pitch; - Your demo has to be accessible over HTTP from within a web browser (ie - from the jury laptop); - You have to submit your demo by adding a URL to the submission page, after which the jury will randomly pick demos from the list; - You have to assign a presenter for your demo. Only one person is allowed to touch the keyboard and mouse. And make sure to test your demo remotely :-); - No slides or code is allowed; the only thing that you'll be judged upon is the running demo; Results of the day: 9 forge projects presented. Interesting components were built that are more or less usable for clients right away. Good integration between the different technologies, lots of interaction between departments / developers, 20 kilo of meat, 60 liter of beer, 1 bottle of cola... This was just the first day in a hopefully long series of Hippo Forge Fridays. We think there are lots of you out there who would like to dive deeper into the Hippo products and built new components together with the experts in the specific Hippo / open source fields. Therefore we decided to organize the first Hippo Forge Friday for everyone who would like to participate in or contribute to the Hippo community. So here we go: What: First international Hippo Forge Friday with friends When: October 30th from 14.00 until 21.00 (CET) Where: Hippo Office Amsterdam, Hippo Office San Francisco or join us through skype/ internet etc Why: To learn all about the Hippo products, create new or expand the current plug-ins, HST components, portlets etc. And to win eternal fame by earning one of the prestigious prizes in the following categories ( The Wow! Factor award, Most customer friendly, Most promising, And of course.. The Nice Try Award (too bad it didn't work out)) Cost: Free (as in free beer ;-) Who: Everyone who has a Hippo heart. If you are interested in joining or want more information, drop an email at "forgefriday at onehippo dot com".

Jeroen Reijn (Hippo): Japanese and Java resource bundles

noreply@blogger.com (Jeroen Reijn) — Fri, 07 Aug 2009 16:01:17 +0000

At Hippo we have a project, which is build with Java Server Faces, for which I occasionally do some maintenance. A while ago I had an issue in our JIRA bug tracker that reported an error for the Japanese version of the website. The error came from a component that reads information from a resource bundle properties file, which is stored on the local filesystem. In this case from the Japanese version of the resource bundle (ApplicationResource_jp.properties), which is used by the web application to display some Japanese labels.

The error wasn't very clear since it only gave the following exception:

java.util.MissingResourceException:
Can't find resource for bundle java.util.PropertyResourceBundle, key 'somekey'

Looking in my project, I could clearly see that the resource bundle was there and after a quick peek at the resource bundle file itself, I could see that the requested key was also present.

After trying some different options I came to the conclusion that my web application was unable to read the actual .properties file from the classpath. By searching some more, I found out that the Java compiler and other Java tools can only process files which contain Latin-1 and/or Unicode-encoded (\udddd notation) characters. Since I was seeing Japanese characters when opening the properties file, it was clearly the case that this file did not meet those requirements.

Solving this issue was quite simple in the end, since the Sun JDK comes with a utility to help you out with files that contain characters, which are not Latin1. The utility is called: 'native2ascii' and can be run from the command-line quite easily by typing:

$ native2ascii [inputfile] [outputfile]

Once I did that the application was working like a charm again!

Niels van Kampenhout (Hippo): Creating a new document through the Hippo Repository Workflow API

noreply@blogger.com (Niels) — Tue, 23 Jun 2009 21:33:00 +0000

It's already a couple of months ago that I wrote about using the Hippo Repository Workflow API. Back then, I explained how to modify an existing document, and request publication. Ever since that blog post I have been getting the same question over and over again: how to create a new document through the repository API?

If you read the previous blog post, and looked at the worklfow API, it might not be directly obvious how to create a new document through the workflow. Think about how a document is created though: it is always created as a child node of an existing node: the parent folder. Creating a new document is actually part of the Folder Workflow!

Knowing this, it all becomes very easy. Let's step through the code:

Let's hardcode some values for simplicity's sake:


String folderPath = "/content/documents/news";
String newDocumentName = "Hippo CMS 7.1 released!";
String newDocumentType = "defaultcontent:news";

We will be creating a new document inside the folder /content/documents/news. This is actually a node of type hippostd:folder, which means a FolderWorkflow applies to this node. We will be creating a new document of type "defaultcontent:news", as provided with the Hippo CMS Quickstart WAR. We will call the new document "Hippo CMS 7.1 released!".

Next, we get the folder node from the repository session:


// get the folder node
HippoNode folderNode = (HippoNode) session.getItem(folderPath);

We also need the workflow manager:


// get the workflow manager
HippoWorkspace workspace = (HippoWorkspace) folderNode.getSession().getWorkspace();
WorkflowManager workflowMgr = workspace.getWorkflowManager();

Using the workflow manager, get the folder node's workflow:


// get the folder node's workflow
Workflow workflow = workflowMgr.getWorkflow("internal", folderNode);

Check if the workflow is a folder workflow, and cast it to a FolderWorkflow object:


if (workflow instanceof FolderWorkflow) {
    FolderWorkflow fw = (FolderWorkflow) workflow;

Now that we have the folder workflow, we can simply call the add method. It takes three String parameters: the category ("new-document"), the node type, and the node name:


// create the new document
fw.add("new-document", newDocumentType, newDocumentName);

That's it! Run the program, and check your CMS. There should be a new document "Hippo CMS 7.1 Released!" visible under the "news" folder. You can edit and publish this document just like any other. To modify the document through the API, see my previous post on this subject.

For your convenience, here is the complete class:


package org.example;

import java.rmi.RemoteException;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.hippoecm.repository.HippoRepository;
import org.hippoecm.repository.HippoRepositoryFactory;
import org.hippoecm.repository.api.HippoNode;
import org.hippoecm.repository.api.HippoWorkspace;
import org.hippoecm.repository.api.Workflow;
import org.hippoecm.repository.api.WorkflowException;
import org.hippoecm.repository.api.WorkflowManager;
import org.hippoecm.repository.standardworkflow.FolderWorkflow;

public class CreateDocument {

    public static void main(String[] args) {
        Session session;
        HippoRepository repository;
        try {
            repository = HippoRepositoryFactory.getHippoRepository("rmi://localhost:1099/hipporepository");
            session = repository.login("author", "author".toCharArray());
            
            String folderPath = "/content/documents/news";
            String newDocumentName = "Hippo CMS 7.1 released!";
            String newDocumentType = "defaultcontent:news";

            // get the folder node
            HippoNode folderNode = (HippoNode) session.getItem(folderPath);
            
            // get the workflow manager
            HippoWorkspace workspace = (HippoWorkspace) folderNode.getSession().getWorkspace();
            WorkflowManager workflowMgr = workspace.getWorkflowManager();
            
            // get the folder node's workflow
            Workflow workflow = workflowMgr.getWorkflow("internal", folderNode);
            
            if (workflow instanceof FolderWorkflow) {
                FolderWorkflow fw = (FolderWorkflow) workflow;
                
                // create the new document
                fw.add("new-document", newDocumentType, newDocumentName);
                
                System.out.println("New document '" + newDocumentName + "' of type '" + newDocumentType + "' created");
            }
            else {
                System.out.println("Workflow is not an instance of FolderWorkflow");
                return;
            }
            
        } catch (RepositoryException e) {
            System.out.println(e.getMessage());
        } catch (RemoteException e) {
            System.out.println(e.getMessage());
        } catch (WorkflowException e) {
            System.out.println(e.getMessage());
        }
    }
}

David Taylor (Hippo): Roadmap Jetspeed 2.2.1

noreply@blogger.com (DST) — Fri, 19 Jun 2009 21:31:00 +0000

I am sketching out a Roadmap for the next Jetspeed release, version 2.2.1. Here was my original plan for 2.2.1, to be based on maintenance and improvements to 2.2.0:

Old Roadmap for 2.2.1

Advanced Portlet API 2.0 Support
Data Migration from 2.1.x to 2.2.x
Bug and Performance fixes to initial 2.2.0 release
Complete implementation of optional JSR-286 Cache features
Improved User and Site Browsing in Admin Portlets
Registry Export

As time passes, priorities change. I have been working with the Hippo Enterprise Content Management suite quite a bit lately, and I realized Content Management goes hand and hand with portals. It is about time Jetspeed gets content management features too. We were originally planning on implementing JCR features in version 2.2.2. After discussions with other team members, we are now looking at the following feature sets for JCR as the top priority for the 2.2.1 Roadmap:

Site and PSML persisted in JCR (Jackrabbit) Repository
Navigation integration with repository: portal can navigate directly to bookmarked content
Automatic publishing of content from repository, immediately accessible in portal
Security synchronized with JCR security

We will still need to provide Data Migration for 2.1.x users, thus the new high level Roadmap for 2.2.1 is as follows:

New High Level Roadmap for 2.2.1

Site and PSML persisted in JCR (Jackrabbit) Repository
Navigation integration with repository: portal can navigate directly to bookmarked content
Automatic publishing of content from repository, immediately accessible in portal
Security synchronized with JCR security
Data Migration from 2.1.x to 2.2.x
Bug and Performance fixes to initial 2.2.0 release
Registry Export

With full Portlet API 2.0 support from version 2.2.0, and JCR support coming in version 2.2.1, we are planting the foundation for developing Java enterprise applications mixed with content.

Jeroen Reijn (Hippo): JCR: Sorting on child node properties

noreply@blogger.com (Jeroen Reijn) — Sat, 13 Jun 2009 17:01:11 +0000

A JCR repository, like Apache Jackrabbit (basis for Hippo CMS 7's content repository), mainly consists of nodes and properties.
As described in the JCR specification, a Java Content Repository should support 2 different query syntaxes: XPath and SQL. Once you get the hang of the syntax, performing a search on a JCR repository is quite easy, but today I came into a situation where I was not able perform the query I wanted. In this post I'll try to describe what my problem was and how the same result can still be achieved.

The content model

Let's first start with my content model. The actual node definition for my project looks something like the below:


[myproject:metadata]
- myproject:creator (string)
- myproject:language (string)
- myproject:publicationDate (date)
- myproject:availableUntil (date)
- myproject:lastModified (date)
- myproject:keywords (string)
- myproject:contributor (string)

[myproject:news] > hippostd:publishable, hippostd:publishableSummary, hippo:document
- myproject:title (string)
+ myproject:introduction (hippostd:html)
+ myproject:body (hippostd:html)
+ myproject:metadata (myproject:metadata)

I came into a situation where I wanted to search for nodes of type 'myproject:news', but sorted on the 'myproject:publicationDate' property of the 'myproject:metadata' subnode. Writing an XPath for such a query is quite easy if you're familiar with the XPath syntax.

Let's start out with a very simple search and just search for nodes of the type 'myproject:news' , which in XPath looks like:


//element( *, myproject:news)

Now if we would want to order these node types based on for instance the myproject:title property the same XPath query looks like:


//element( *, myproject:news) order by @myproject:title descending

Now if we would want to sort on the 'myproject:publicationDate' property of the myproject:metadata subnode, I would expect the same XPath to be:


//element( *, myproject:news) order by myproject:metadata/@myproject:publicationDate descending

Unfortunately this query did not seem to actually sort the result on the publicatenDate property as I would have expected. I was searching for typos first, but it appeared that the syntax of my query was ok, but it appeared that support for child axis in order by clauses was not yet supported by Jackrabbit itself.

Then I found this JIRA issue[1] in the Jackrabbit bugtracker describing this problem and there appears to be a patch available. I'm still wondering how much of a performance impact this might have for large repositories, where you might want to sort on a property of a child node 'n'-levels deep underneath the actual node.

If you want to sort on properties of a specific nodetype, you will have to add the sortable properties to the actual nodetype, which you are searching for and can't put them on a subnode.
It seems that the patch, which should fix this problem, has already been comitted to the Jackrabbit trunk and should be available from Jackrabbit 1.6.0 as marked in the JackRabbit JIRA.

Woonsan Ko (Hippo): Spring Web MVC framework support in HST-2

Fri, 05 Jun 2009 16:28:37 +0000

Spring Web MVC framework support in HST-2

HST-2 has provided a basic support to enable developers to utilize Spring Framework IoC container for HST components. [1]
Now, HST-2 provides even more. It supports Spring Web MVC Framework based applications under HST-2 environment! Using

Jasha Joachimsthal (Hippo): Hippo Site Toolkit Query interface and pagination

Jasha Joachimsthal — Thu, 04 Jun 2009 18:01:43 +0000

Today an interesting question came from a developer of one of our implementation partners. He wanted to list items from our JCR repository and use pagination. In this post I tried to make a summary out of the conversation.

The query was:

      HstQuery query = getQueryManager().createQuery(requestContext, scope,
      filterBean);
      Filter filter = query.createFilter();
      filter.addContains(".", "my keywords");
      query.setFilter(filter);
      HstQuery queryResult = query.execute();

The developer tried to get a paged result and the total number of items with:

      query.setOffset(0);
      query.setLimit(10);

      HippoBeanIterator hits = queryResult.getHippoBeans();
      hits.getSize();

The result contained indeed 10 items but hits.getSize(); also returned 10. What's going wrong? Ard Schrijvers explained:

If you use setLimit(3), you will get at most 3 hits, but never more. getSize() from the queryResult returns at most 3. Even if the search criteria matched hundreds of documents. If you use offset(10) and no limit, getSize() returns just 10 hits less then without the offset.

This limit is there to be used for performance, and suits for example very well "show last 3 agenda items on homepage".

If you need paging and only want 10 results, do not use setLimit(int limit).

What you do use, is just the query without setLimit(). Then you'll get back a queryResult, from which you get a HippoBeanIterator. This is a normal Iterator, with some extensions. A very important one is the method skip(int skipNum).

From the HippoBeanIterator, you can simply iterate the beans you need. Make sure you use skip(int skipNum) to jump to the correct place. If the current page is 11 and pagesize is 20, set skipNum to 220.

Then fill your List in a for loop from skipNum - skipNum + pageSize.

What about performance?

The skip is propagated to the JCR NodeIterator. If you want to display item 100-110, and you use skip(100), still only 10 Beans will be created. JCR nodes for Beans 0-99 are not fetched.

What if you need the total number of hits?

Use getSize(). The getSize() on the the HstQueryResultImpl or on the HippoBeanIteratorImpl does not actually populate the entire iterator with HippoBeans. It is a call through the JCR NodeIterator, which in JackRabbit is some lazy loading iterator, and, where the getSize is propagated to the executed query, without fetching actual nodes.

Niels van Kampenhout (Hippo): HST Components at Hippo Forge

noreply@blogger.com (Niels) — Thu, 21 May 2009 18:01:42 +0000

In the past couple of days I slapped together two simple components for use with the Hippo Site Toolkit 2: RSS Feed Creator and List Builder. At this moment, their names are more fancy than their actual functionalities ;-) but the idea is to provide some basic building blocks that people can take and extend. Both components are hosted at Hippo Forge, so the source code is available and you can do with them whatever you want. Go ahead and take them for a test drive. If you think you can improve them (not that hard), feel free to contribute your work. I am happy to apply your patches. I might even consider giving you commit rights! ;-)

The Forge is actually starting to become a well stocked library of CMS and HST components. Check out the Related Items Plugin; It helps you creating a list of documents related to the one you are editing, by making suggestions. Just one example of reusable functionality that you can add to your CMS project. Doesn't match your exact requirements? Adapt it, it's open source! Made a component for your project that is useful for others? Add it to the Forge!

Jasha Joachimsthal (Hippo): I don't want to register before downloading

Jasha Joachimsthal — Sat, 16 May 2009 12:01:19 +0000

Okay I just wanted to try the "community edition" of some software. So I clicked on the big download button and then... I had to login. Because I don't have an account yet I had to register first. So I filled in all required field like my email address and a free to choose password without any help message about it's strength and then I got this error message:

Password not strong enough. Please use at least 3 of the following prerequisites:lowercase (a-z), uppercase (A-Z), numbers (0-9), and special characters (!^%#$@*.,)

Come on, I just want to try some software. Just let me download it without creating an account I will probably never use again. When I want to post on your support forum that's the right moment to create an account. I wonder if these companies have ever looked into their website statistics to see at which point people quit.

Jasha Joachimsthal (Hippo): Hippo developer training

Jasha Joachimsthal — Mon, 27 Apr 2009 06:20:00 +0000

Hippo let me follow the three day developer training for CMS 7 and Hippo Site Toolkit 2 (HST2) by Jeroen Reijn. I don't live inside a cocoon so I knew already which new products had been developed. Until now I hadn't done any implementation yet with Hippo CMS 7 and the HST2 because I was too occupied with Hippo CMS 6 projects. Since I'm also a Hippo trainer it was a good chance to get to know our new training programmes.

Day 1: introduction

After we received the handouts of the training we introduced ourselves. It was a pretty mixed group with developers from partner implementation companies, an independent consultant, developers from a customer and me. Jeroen explained the Hippo architecture which is basically still the same as with version 6 but based on different technologies. The WebDAV repository has been replaced with our JCR Repository (based on Apache Jackrabbit) which also uses Apache Lucene for fast indexing & searching. Hippo CMS 7 is still an application that runs separate from the repository and has been written in Apache Wicket. For front end applications you're free to choose a technology but Java is recommended because of the J in JCR ;)

Jeroen showed us the CMS and the Console to show what's happening inside the repository. The trainees all got a laptop from Hippo with a VirtualBox image for the training to "play" with the CMS and the console. No need to bring your own laptop for the first two days!

Day 2: changing templates and HST2 introduction

After some explanation we started to create our own document type. We used version 2.03.00 (later versions have some issues with the graphical template editor which are being solved soon). With just a few mouse clicks I had a "blogpost" template with a date, title, WYSIWYG field and a checkbox for "allowing" comments. Because this template isn't very difficult, it's nice to create it by the GUI editor instead of creating XML configuration by hand (which is still possible if you like to).

After lunch Jeroen started explaining the Hippo Site Toolkit version 2.03.02. The HST is not a framework but a toolkit to create your own website using Hippo CMS and Hippo Repository. At this moment there's an HST for JSP sites but other (Java) technologies may follow in the coming years. On the VirtualBox image there is a sample site with a navigation structure, a news listing and a view for detail pages. All configuration for the menu structure, sitemap (mapping between URLs and repository paths), pages and templates is done in the repository. Now you have to do it by hand but in the near future there will be a configuration editor in the CMS. That would make it easy for the webmaster to change the URL structure or the way pages look.

The URL mapping is easy to understand if you know how matching works in Apache Cocoon. _default_ is the equivalent of * in a Cocoon sitemap and _any_ is equal to ** in the WildCardMatcher. A navigation structure like

      News
      |- _default_
      |- _default_
      |- _any_.html

would match a URL like /News/2009/04/My_blogpost.html. The "wildcards" _default_ and _any_ can be added as parameters to the rendering class that can pass it to the JSP so you can display "April 2009" in the title of your news overview if a visitor goes to /News/2009/04. As last exercise we added a new document type for events in the CMS, created some events and added a new event listing to the existing example site.

Day 3: create your own site from the Maven archetype

For this day we were asked to bring our own laptop so we could leave with a functional website at the end of the day and have all the necessary software installed to create another. Jeroen explained about Maven en let us create a project using the Maven archetype:

      $ mvn archetype:generate \
      -DarchetypeRepository=http://repository.onehippo.org/maven2 \
      -DarchetypeGroupId=org.onehippo.ecm.hst \
      -DarchetypeArtifactId=hst-archetype \
      -DarchetypeVersion=2.03.02 \
      -Dversion=1.01.00 \
      -DgroupId=org.example \
      -DartifactId=myproject

It creates a project on the file system in three parts: the content, CMS and the site. After lunch we started to build our own website. I took the Urban-net website as example because it has an easy layout (1 header and 3 columns: left hand navigation, dynamic content in the centre and some downloads on the right hand site).

First I created two document types, one for normal text and one for "research programmes" (leaving away some fields compared to the original site). Then there was the time consuming part: copy-pasting enough content for a decent paging in the site. For real projects there are migration tools available to convert the XML content from the WebDAV repository to JCR nodes and properties. For the themes I used an ordinary repeating text field but the Hippo ECM Tagging add-on would be more user friendly in a real life implementation.

After defining the several sitemenu parts, components, pages and templates it was time to add the design and copy-paste the HTML into the JSP's. I couldn't implement everything I wanted (helped others as well and the time was limited). However in just a few hours I managed to implement a subset of the normal site. It does not contain search, no faceted navigation, the links on the right hand site are fake but it does show the basics.

After the training it was time to enjoy the beautiful weather on our balcony with some drinks and chips.

Woonsan Ko (Hippo): Spring framework support in HST-2

Mon, 20 Apr 2009 10:04:55 +0000

I'd like to explain the current status to support Spring Framework-based developer community. HST-2 (Hippo Site Toolkit - 2) now supports Spring Framework more than the earlier versions because there are a lot of developers utilizing the framework. 1. Introduction It is very desirable to use spring web framework if the development team is familiar with Spring and they could make better productivity with that. HST-2 now provides a bridge HstComponent to HstComponent beans which are managed by spring web application context. So, you can define your HstComponent beans in your spring context configuration and inject your existing component to them. You can see an example in the HST-2 source already if you download the source from the trunk for now. In the /applications/site/, 'contact-spring' menu will show the example which uses the bridge component. The actual bean is defined in /WEB-INF/applicationContext.xml like the following:

  <!-- HST Component Beans -->
  <bean id="contactBean" class="org.hippoecm.hst.components.ContactSpring">
    <property name="mailSender" ref="mailSender" />
    <property name="templateMessage" ref="templateMessage" />
  </bean>

  <!-- The existing components as an example -->
  <bean id="templateMessage" class="org.springframework.mail.SimpleMailMessage">
    <property name="to" value="contact@mycompany.com" >
    <property name="subject" value="My opinion" >
  </bean>
  <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="host" value="mail.mycompany.com"/>
  </bean>

2. How it integrates with HST 2.3? HST container manages, invokes and aggregates only components based on HstComponent interface for some reasons: to support transparent page aggregation, seamless portal integration, etc. A generic HstComponent was developed to play a role as a bridge to a bean managed by spring framework. So, the generic bridge HstComponent will delegate all invocation to the actual HstComponent bean managed by spring framework. 3. What the benefits are? What the drawbacks are? Spring-based developers can use full cool functionalities of spring framework like Dependency Injection, out-of-box spring components to support enterprise computing like JDBC template, transaction management and enterprise messaging, AOP techniques, Web Service support, Various view technologies, etc. HstComponent can be fully integrated with these rich spring supports. The Spring bridge HstComponent invokes directly the actual bean, so there's no performance degrade and functional shortage here. Of course, it looks a little bit different from the original spring web mvc pattern. The differences you can think of are originally from the differences of goals: HST-2 is to support transparent page aggregation and seamless portal integration, etc. Because HST-2 container aggregates multiple components in one page, the action phase should be separated from the rendering phase of all components. This means that HST container's aggregation should imply the PRG pattern internally. [1] Therefore, in a HST component, the *controlling* logic should be separated in doAction() and in doBeforeRender(). Also, those two separate phase should have separate request life cycles. Anyway, once you get accustomed to HstComponent request l

Niels van Kampenhout (Hippo): Coming soon to a computer near you: Hippo Site Toolkit 2!

noreply@blogger.com (Niels) — Mon, 13 Apr 2009 23:01:32 +0000

It's almost finished! Hippo Site Toolkit 2 will be released really soon now. I am working on the documentation right now and I have to say I am impressed by the work of our development team.

Hippo Site Toolkit 2 is a very versatile and lightweight component based framework for building websites on the Hippo CMS stack. Very much in Hippo tradition, we do not enforce you to use any particular technology or framework, but rather give you freedom of choice and the building blocks you need.

Some highlights among the many features of Hippo Site Toolkit 2 are:

Component based
HST2 lets you create reusable components and assemble webpages from those components.

Transparent support for portlets
HST2 components can be used out of the box as portlets in a portal environment.

Framework independent
Although our primary focus is JSP, any Java web framework can make use of HST2 functionalities. A Spring MVC example is included.

Plain Java
HST2 does not enforce any "dominating technology" that has been built on top of Java, such as Cocoon or Sling. It's all plain old Java.

Rapid website development
HST2 includes a web based configuration GUI embedded in Hippo CMS, and many reusable out of the box components.

There is no official release yet, and it's still a little rough around the edges here and there (you need to use the CMS Console for some configuration), but it is already usable. If you want to live on the edge, check out the trunk and give it a go (see the README). If not, stay tuned while we finish up the release and the documentation!

Niels van Kampenhout (Hippo): Publishing Maven artifacts for your Hippo Forge project

noreply@blogger.com (Niels) — Tue, 31 Mar 2009 16:06:00 +0000

Do you have a project on Hippo Forge? Then you might want to deploy artifacts in a Maven repository, so your projects can be added as a dependency to other Maven projects. Hippo Forge has no central Maven repository, but you can use your project's SVN repository to publish the artifacts. To do this, you can use wagon-svn, a Maven Wagon provider for Subversion.

The first thing you need to do is create a space in your SVN repository to deploy the artifacts in. If your project's SVN repository is at http://forge.hippo-ecm.org/svn/myproject/, create a folder maven2 in the root of the repository, i.e. http://forge.hippo-ecm.org/svn/myproject/maven2/.

In your project's POM, add the wagon-svn extension to the build section:


  <build>
    ...
    <extensions>
      <extension>
        <groupId>org.jvnet.wagon-svn</groupId>
        <artifactId>wagon-svn</artifactId>
        <version>1.8</version>
      </extension>
    </extensions>
  </build>

Then add a distributionManagement section to your project's POM, and specify the SVN location you created as the Maven repository to deploy artifacts to. For the id you can use any string you like.


  <distributionManagement>
    <repository>
      <uniqueVersion>false</uniqueVersion>
      <id>myproject-maven-repo</id>
      <url>svn:http://forge.hippo-ecm.org/svn/myproject/maven2/</url>
    </repository>
  </distributionManagement>

Finally, add credentials for the Maven/SVN repository to your Maven settings.xml, located in the .m2 directory in your home directory (e.g. /home/username/.m2/settings.xml on Unix). Right under the settings element, add a servers element:


  <servers>
    <server>
      <id>docselector-maven-repo</id>
      <username>myname</username>
      <password>secret</password>
    </server>
  </servers>

You should now be able to deploy artifacts to the SVN repository using the following command:


mvn deploy

Don't forget to add the location of the Maven repository to your project documentation! People need to add that repository location to their project POM or settings.xml in order to download dependencies from it.

Jeroen Reijn (Hippo): Apache Camel: open source integration framework

noreply@blogger.com (Jeroen Reijn) — Tue, 31 Mar 2009 13:01:22 +0000

I'm currently working on a project where we are looking at creating an integration layer for external applications to connect to our back-end applications. In our case, one of the back-end applications is Hippo CMS 7's repository.

I've been reading up on ESB's like Apache ServiceMix and Synapse, but even though both projects look very interesting, they actually are a bit too much for what I want to do. There was one project though that seems to be exactly what I want: Apache Camel.

About Apache Camel

Apache Camel is an open source Java framework that focuses on making integration easier. One of the great things is that Camel comes with a lot of default components and connectors.
Even though I was quite new to the integration concept, I was able to get my first Camel project up and running within 30 minutes or so, which I think is quite fast. You only need is a bit of Java/Spring knowledge to get going.

The basic concepts

While using an integration framework like Camel, you will have to keep four key terms in mind:

Endpoint: where the message comes in or leaves the integration layer
Route: how a message goes from endpoint A to endpoint B
Filter: the chained components that are involved in the process of handling a message that comes from endpoint A and goes to endpoint B. It could be that the content of the message needs to be transformed from SOAP to for instance ATOM.
Pipe: the way the message travels from endpoint A through filters to endpoint B

One of the things I'm looking at Camel for is using it to convert RSS feed entries into JCR nodes. If I would create an endpoint diagram, which would describe my route, it would look something like the image below.

With Camel, the endpoints and routes can be configured in a few lines of Java code or with Spring XML configuration. I started out with the Spring XML configuration and it was actually quite easy to get going. Here is an example where I poll my own RSS feed and store the items into a mock 'feeds' object.

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

  <camelContext xmlns="http://camel.apache.org/schema/spring">
    <route>
      <from uri="rss://http://blog.jeroenreijn.com/feeds/posts/default?alt=rss" />
      <to uri="mock:feeds"/>
    </route>
  </camelContext>

</beans>

As you can see that's just a couple of lines of code. It's really that simple to do things in Camel. Of course this configuration does not end up in a JCR repository, but as an example I think it's quite easy to grasp. For those of you, that want to play around with Camel as well, I'll try to explain all the step I took to get a working web application example from here on. As I'm using Maven2 for building my projects, you should be able to reproduce my setup quite easily.

Setting up your maven project

First off we'll start with adding the camel dependencies to our maven project descriptor( pom.xml).

<dependencies>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <version>${camel-version}</version>
  </dependency>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-spring</artifactId>
    <version>${camel-version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring-version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring-version}</version>
  </dependency>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-rss</artifactId>
    <version>${camel-version}</version>
  </dependency>
</dependencies>

As you can see I explicitly added the camel-rss component, so that my camel application knows how to handle rss feeds. Camel does not have it's own RSS parser, but is using Rome in the background for handling the RSS feeds. The Camel project is setup in such a way that you can include any component you want, by adding the needed component dependency to your pom.xml. If you're thinking about using Camel, make sure you checkout the components page, which shows you all of the currently available components.

Camel uses Spring, so we need to add the Spring ContextLoaderListener to the local web.xml in src/main/webapp/WEB-INF/.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

The last step in our process is defining our endpoints. In my case I chose to use the Spring XML configuration for defining my endpoints.

Add a file called applicationContext.xml to your src/main/webapp/WEB-INF/ folder.
Once the file is created you should be able to define your routes like this:

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

  <camelContext xmlns="http://camel.apache.org/schema/spring">
   <route>
     <from uri="rss://http://blog.jeroenreijn.com/feeds/posts/default?alt=rss" />
     <to uri="mock:feeds"/>
  </route>
</camelContext>

</beans>

In this example I'm using my own RSS feed, but you can of course use any feed url you like.
For testing purposes you can add a log4j.properties file in src/main/resources/, so you can see the output of the Camel RSS component in your console. Here is the configuration I used writing this blogpost.


# The logging properties used for eclipse testing, We want to see debug output on the console.
log4j.rootLogger=INFO, out

log4j.logger.org.apache.camel=DEBUG

# uncomment the following line to turn on ActiveMQ debugging
# log4j.logger.org.springframework=INFO

# CONSOLE appender not used by default
log4j.appender.out=org.apache.log4j.ConsoleAppender
log4j.appender.out.layout=org.apache.log4j.PatternLayout
log4j.appender.out.layout.ConversionPattern=[%30.30t] %-30.30c{1} %-5p %m%n

Well that's it. Now the only thing you will need to do is fire up an application container, like Jetty and see what's going on in the console.

$ mvn jetty:run

If Jetty is running and everything is setup correctly you should be able to see some debug information come by that looks like:


  SyndFeedImpl.author=noreply@blogger.com (Jeroen Reijn)
  SyndFeedImpl.authors=[]
  SyndFeedImpl.title=Jeroen Reijn
  SyndFeedImpl.description=
  SyndFeedImpl.feedType=rss_2.0
  SyndFeedImpl.encoding=null
  SyndFeedImpl.entries[0].contributors=[]

As you will see the RSS feed is parsed and converted into a SyndFeed object.
From there on you can make use of this object and perform any operation on it.

I must admit that while playing around with Camel and RSS feeds,
I noticed that the RSS (and Atom) component did not handle extra request parameters correctly, so I added a patch in the Camel JIRA, hoping it wil be included in the next release of Camel.
If you have issues with the RSS component and request parameters, you might want to try to build the Camel SVN trunk and apply my patch (CAMEL-1496).
This is only necessary if you want to parse a feed that has for instance a unique id as request parameter added to the feed URL.

We'll that's it! This post will get a follow-up, where I will show you have to use Camel to actually store the RSS feed entries into a JCR repository.

Here are a couple of good articles too read before starting with Camel:

This blogpost was inspired by an article over at Gridshore, where Jettro wrote a post on using Spring Integrations as integration framework. Since I'm pretty much Apache minded, I have been looking around for other open source integration frameworks within the ASF, which brought me to Apache Camel.

Planet Hippo

Bas van Leeuwen (Hippo): Inspiring: Hippo GetTogether

Rolf van der Steen (Hippo): Usability test: Tab Management

Rolf van der Steen (Hippo): Results Hippo GetTogether Usability Sidetrack

Rolf van der Steen (Hippo): Hippo GetTogether Usability Sidetrack

Mathijs Brand (Hippo): The little secret about Search Engine Optimization

Paula knows

Keywords

Link farms

Performance matters

Nice, nice, nice, but now I want the secret

Rolf van der Steen (Hippo): Hippo GetTogether T-shirt poll

Ard Schrijvers (Hippo): Relevance scoring your search results with the HST Query

Jasha Joachimsthal (Hippo): Reusing content with Hippo CMS

Tjeerd D. Brenninkmeijer (Hippo): Performance does matter..

Jasha Joachimsthal (Hippo): Show Tweets with HST and Twitter4J

Update about authentication (22-07-2010)

Rolf van der Steen (Hippo): Usability test: Insert / Modify Image

Rolf van der Steen (Hippo): Results usability test: Done vs. Save and Close

Jasha Joachimsthal (Hippo): Web development tools I use at Hippo

Web developer toolbar

Firebug

Yslow

YUI compressor

WAVE

Different Internet Explorer versions

Rolf van der Steen (Hippo): Usability test: Done vs. Save and Close

Jeroen Reijn (Hippo): An introduction to Hippo CMS 7 updater modules

Writing an Updater module

Updaters and versioning

Visitors

How to use a visitor in your module

Adding the updater module to your deployment

Vijay Kiran (Hippo): Faceted Navigation with Hippo CMS and HST2

Introduction

Rolf van der Steen (Hippo): Designing Complex Applications

Vijay Kiran (Hippo): Multi Channel Publishing with Hippo CMS and HST

Introduction

What is Multi Channel Publishing?

Web Page

iCalendar Format (ics)

Mobile (iPhone)

Augmented Reality Layer

Content Model

Presentation of Data

Web Page

iCal/ICS format

Mobile (iPhone using jQTouch)

Augmented Reality Layer (Layar)

Conclusion

Jeroen Reijn (Hippo): Giving Hippo CMS 7 some WebDAV support

What is WebDAV?

Enable WebDAV support for your Hippo CMS 7 project

In action

Current status

Jasha Joachimsthal (Hippo): Components in my blog: Properties component

Mathijs Brand (Hippo): There's a Hippo on my Ipad

Jasha Joachimsthal (Hippo): First blogpost in Hippo

Mathijs Brand (Hippo): Smoothly going through a Hippo CMS project

Mathijs Brand (Hippo): Limited choices

Jeroen Verberg (Hippo): Open source business model

Lars Peters (Hippo): On Search Engine Optimization: Why canonical URLs matter

Rijden onder invloed harder aangepakt | Nieuwsbericht ...

Jeroen Reijn (Hippo): Metadata extraction with Apache Tika

Content metadata

What is Apache Tika?

Getting started

The actual code

Looking ahead

Arje Cahn (Hippo): The Dutch national government has a brand new website

Tjeerd D. Brenninkmeijer (Hippo): OSBC 2010: open source is much more than just a money saver

Arje Cahn (Hippo): Hippo CMS 7.4 preview: version compare

Arje Cahn (Hippo): What's wrong with portals?

Tjeerd D. Brenninkmeijer (Hippo): Five golden rings, four golden Hippos and one platinum Hippo

Jeroen Reijn (Hippo): Jboss ModeShape: A federating JCR repository

What's ModeShape?

Connectors

Sequencers

Conclusion

Lars Peters (Hippo): Why WCM/Portal convergence is a good thing