Search posterous

Search all posts and users. Type a name, type a favorite song title, whatever! See what comes up.
  

More posterous blogs











More recommended blogs »

Here are posterous posts filed under opencms...

The web content management space is not homogeneous. And while the recently released Open Source CMS Market Share Report clearly highlighted the ongoing dominance of LAMP-based content management systems — these systems are not the only game in town.

In this article I look at brand leaders who have chosen to build their content management software on the Java or .NET technology stacks. Systems with strong brand awareness and adoption rates include Alfresco, Jahia, Liferay and OpenCMS on the Java side, and DotNetNuke and Umbraco from the .NET camp.

Looking Beyond LAMP

The LAMP stack is populist in nature. Not only does the stack carry the cost advantages of open source, but there also exists a wide assortment of low-cost hosting and a ready (and growing) supply of developers. These characteristics create low barriers for entry and an attractive choice for individuals, hobbyists and small to medium sized enterprises.

While few would dispute that there are numerically more deployments of the common LAMP stack systems, it would be a mistake to assume that this is the only platform that matters.

LAMP Systems Often Fail to Meet More Sophisticated Needs

The web content management space is not homogeneous. A hobbyist building a personal site, a small company building an online marketing presence, and a medium sized enterprise building a portal for customer relationship management are just three examples of widely disparate, yet common uses.

And while it is possible that all three of those groups might be looking at the same systems, it is more likely that those who require higher level functionality will look beyond the most common PHP-based systems. This argument becomes even more persuasive when you look at enterprise level clients.

PHP Systems Not Often on Enterprise Short Lists

For clients who demand more functionality, higher security and more robust platforms, Java-based and .NET-based content management systems hold a strong attraction. Indeed, in the enterprise space, those platforms are more likely to be the first choice.

Though it is certain that The Big Three — Joomla!, WordPress and Drupal — continue to improve their offerings and are more capable of supporting robust websites, I think it is fair to state that at this point in time few enterprise clients put them on their shortlist.

A Vibrant Java CMS Race

We included 4 Java-based systems in the survey: Alfresco, Jahia, Liferay and OpenCMS. Of the four, Alfresco topped the set in virtually all the metrics we looked at — in many cases ranking closely behind The Big Three PHP systems. It was a very strong showing for a system that is not normally thought of in the context of web content management (Alfresco primarily markets itself as a document management, Enterprise CMS or records management solution).

Liferay Demonstrates Brand Strength and Social Media Prominence

Alfresco had a strong lead over the other systems in brand recognition and brand familiarity ratings. While Alfresco lead Liferay in many metrics, it did not do so across the board; Liferay also performed very well. Liferay showed significantly greater strength in third party support, website popularity metrics and social media prominence.

Both Alfresco and Liferay ranked highly in the brand sentiment metrics, with Alfresco coming in third overall in 2009 survey — one of the clear leaders in this key metric. Liferay was not far behind, coming in sixth overall.

OpenCMS and Jahia Present but Lagging

Alfresco and Liferay lead OpenCms by a large margin in almost all categories and Jahia not only lagged relative to the other Java based systems, but was one of the weakest performers of the entire survey group. Most troubling for Jahia has to be the brand sentiment data which showed Jahia fourth from last in the survey set, with negative sentiment running very close to 50%.

In sum, from my perspective those interested in implementing Java-based open source content management systems for their web sites have a lot to cheer about. There exist several viable choices and at least two strong, growing players. This is a space that is set to grow and remain competitive in both the short and medium terms.


Survey Question: "Which of these companies or projects have you heard of?" (622 responses)

Lonely .NET Players Waving the FOSS Flag

.NET is not a platform most people traditionally associate with open source, but over the last couple of years that has begun to change. A large part of that credit has to go to the DotNetNuke team, who have been waving the open source flag and investing heavily in marketing that message.

Perhaps no other system in the survey has shown a more concerted marketing effort than DotNetNuke. That marketing has paid off in brand recognition and has opened the door for .NET as an open source alternative in the minds of many consumers.

DotNetNuke Far Ahead Yet Facing Challenges

This year’s survey found that DotNetNuke leads the .NET open source CMS race over the nearest rival, Umbraco, by a significant margin. However, the good news for DotNetNuke seems to stop right about there.

Our survey found an ongoing deterioration in DotNetNuke market interest; a slide that has continued across the last several years. The system also had one of the worst ratios of trial usage to actual usage. In other words, while they were successful in getting prospects to try the system, they were less successfully in converting them into actual users. Most troubling of all were the numbers relating to brand sentiment.


Survey Question: "What is your general feeling about these companies or projects?" (622 responses)

DotNetNuke finished last of the entire survey set in brand sentiment and was one of only two systems to show more negative than positive responses to the question “What is your general feeling about these companies or projects?”

Further corroboration of this conclusion can be found at the Windows Web App Gallery which lists user rankings for four .NET-based content management systems. Of the four, DotNetNuke is ranked the lowest, lagging behind Umbraco, mojoPortal and Kentico CMS.

Team Umbraco Gathering Strength

Aside from the brand sentiment metric, DotNetNuke lead Umbraco across the board. However, when you look at the trend in interest levels, there is a sharp contrast: Interest in Umbraco is strengthening. The improvement is slow but steady and the gap between the two systems seems to have closed significantly in the last 12 months. One has to wonder what would happen if Umbraco could match the marketing might of DotNetNuke.

In conclusion, the .NET-based open source CMS market is still wide open. DotNetNuke was certainly the early mover but seems struggling now to hold on to that advantage. The arrival of competing systems like Umbraco, and even more recently mojoPortal, shows that there is plenty of room for competition in this space, and that things are only going to get more challenging for DotNetNuke.

The data underlying these conclusions can be found in the 2009 Open Source CMS Market Share Report, from water&stone and CMSWire. Download a free copy of the report at: http://www.cmswire.com/downloads/cms-market-share/.

About the Author

Ric Shreves is a partner at water&stone, a digital agency specializing in open source solutions. He was the lead analyst on both the 2008 and 2009 Open Source CMS Market Share Reports. He can be reached at www.waterandstone.com.

Filed under: open cms

mathiaslin says...

[From: http://www.isia.org.hk/]
Aug 2009, After two years of development, the TaoYuan Project team formed by ISIA and HKMA are pleased to announce that CMS 3.0 is born! The CMS 3.0 is the first Open-Source clinic management software in Hong Kong. The latest version 3.1 is available now for all registered doctors and clinics to download together with online e-learning and user manual. ISIA members provide various customized CMS service packages bundling hardware, broadband, data migration, training & hotline support.
For details, _http://cms3.isia.org.hk
_

Filed under: opencms

The struggle for optimal site performance is a battle all web designers & site owners face from time to time. You see a lot of sites on the web that load slowly or perform poorly. While some sites have hosting issues, most are simply built without performance in mind. Joomla!, in and of itself, is neutral in terms of site performance; it's how you configure it and what you do with it that creates -- or prevents -- solid site performance.

This article is excerpted from Ric Shreves' upcoming title, the Joomla! Bible, from Wiley & Sons. That book is due for publication in early November and can be pre-ordered directly from the publisher at www.wiley.com. Watch this site across the coming months as we preview more from this new title. This article orignally appeared on the author's site, RicShreves.net.

This article is an excerpt from the chapter on Site Performance, and it includes information about content and technical issues that impact site performance. As performance factors are not purely Joomla! issues, many of the tips (particularly in the content section) are applicable to any website. Note that Joomla's caching controls are not discussed in this text below, as the first portion of the chapter (not shown here) deals with Joomla! caching in some detail.

Content Issues Affecting Performance

Everything that is on the pages of your website has an impact on the site’s performance. If you build large pages with large files, the page will load more slowly than a smaller, lighter page. While the pages your Joomla! site generates from Components are largely beyond your control, you can have a significant impact on your Articles pages. If you work smart and keep in mind the need to build lean pages, you can serve web pages to your visitors more quickly as well as reduce the burden on your server. Never forget, it all adds up. If you have multiple visitors on your site simultaneously, the page each is viewing contributes to the load. Saving a few kilobyte in file size here and there can add up quickly.

Here is a list of issues and tips you should consider when creating content for your site:

Avoid large files

This is most commonly an issues with graphical files inserted into Articles. Optimize your images to keep file sizes down to reasonable levels. As image file size is at least partially a by-product of the physical dimensions of the image files (width and height), it is hard to say what is right for your site, however a reasonable goal is to keep your images under 50K in size. If your images are too large to achieve that goal without a loss in quality, you may want to consider whether you need to display images that large on the page, or perhaps you should consider whether a better course would be to display a smaller image, a thumbnail, that is clickable to open a larger image. Note also that for the web, image resolution of 72 dpi is sufficient; anything higher is overkill and unlikely to be reflected in the user’s monitor. If you are using the Firefox web browser, there are two free add-ons that can help you diagnose and solve performance problems. The YSlow and Firebug add-ons include tools that help you identify the sizes of all the files on any particular web page. This is a great way to identify problem areas and bottlenecks. YSlow also provides suggestions for improving performance. Get both extensions from https://addons.mozilla.org

Save images in the right format

Closely related to the point above is this issue: use the right image format for the content you need to display. The most common formats for web use are .jpg (or .jpeg), .gif and .png. Use .jpg for photos and anything that requires smooth transition from color to color or large amounts of detail. Use .gif or .png for anything that is primarily large blocks of color or black and white. For example, photos are best saved as .jpgs. A chart or a graphical illustration is best served as a .gif or .png. Given a choice between .png and .gif, prefer .png as it produces a smaller file and is copyright-free. Choose .gifs if you need animation, as .png does not support this, or if the file is very small, in which case .gif often produces a smaller file. Tip: .png files can be created either interlaced or non-interlaced. Interlaced files provide progressive rendering, that is, they render little by little on the screen, starting out fuzzy and getting clearer. Avoid interlaced .pngs. They are larger in size and they confuse some users.

Don’t re-size images

Upload your image in the actual size that it will be displayed. Do not, in particular, upload files larger than what is needed then force them to re-size into a smaller display. Forcing the images to a new size not only fails to save file size, as the file size remains constant, but it also forces the system to do additional work to re-size the image dimensions.

Keep your code clean

If you are copying and pasting text into your WYSIWYG editor, pay careful attention to the code that results. While the system will do its best to eliminate unneeded tags and redundant code, it is always best to look at it yourself and make sure that no redundant tags and inline style definitions have found their way into your page formatting. One of the worst culprits in this area is text copied from older versions of Microsoft Word. The clean up option on the default WYSIWYG browser can help, but a manual check is always the best solution. Note also that valid code renders faster, so it is always a good idea to validate your HTML and CSS.

Avoid tables

To the extent practicable, use CSS to format your page layouts. Tables slow things down as the whole table needs to be assembled before the contents are rendered. Tables also have implications for accessibility. Complex tabular data may require the use of tables, but as a general rule, CSS is the better way to go.

Use image rotators conservatively

Image rotators are Modules that provide a rotating image inside a Module position on your page. A popular technique you see on many websites today is the use of a rotating image on the header of the page. The rotator works like a slideshow, displaying a series of images as the visitor is looking at the page. The problem is that many of the Extensions that provide this functionality require all the images to load before the rotation occurs. This means that a large amount of data is loaded for the page, some of which may be completely pointless as the user has already clicked and moved on before the image displays. If you have to use an image rotator, keep the image sizes small and do not load too many images into the sequence; three images in rotation will perform much better than four, five or six images. If front page performance is a key concern, keep image rotators off the front page.

Use Wrappers reluctantly

Wrappers are used to display a web page inside of your web page. This means that the Wrapper contents have to fetched and displayed inside your page. By definition this increases the number of HTTP requests that have to be made to complete the page, thereby increasing the loading time of the page. Where the web page you are wrapping is located on another server, the display of the Wrapper content will depend upon the performance of the remote system and upon the quality of your connection to that server. All of these factors add up to a greater risk of disruption and to increases in page loading time. If, on the other hand, the wrapped content is kept on your server, the risk decreases dramatically, but the delay factor remains. If front page performance is a key concern, keep wrappers off the front page.

Limit use of animation

Animation files tend to be larger in size and must load in their entirety before they function properly. Accordingly, limit the use of animation on your page to keep page file size down.

Limit use of Flash

Flash files can be quite large in size and they keep your visitors waiting as they spool in to play. If you must use Flash on your pages, use only Flash elements inside the page, rather than use Flash for the entire page content area. Also plan your Flash so that there are not long delays for your viewers.

Don’t stream video until requested

If you wish to give users access to video files, do not stream the video until requested by the user. While this does mean that users who want to view the video have to wait for it, it does not force all the users to endure slow page loading while a file they may never view eats up their bandwidth.

Performance Tuning

This section looks at various techniques you can use to tweak the performance of your Joomla! site. Not all of these suggestions will be suitable for your site, but certainly some of them will be applicable.

Use server side compression

Joomla! support the server side compression protocol GZIP. If your server supports GZIP, enable this option in the Global Configuration Manager as it can result in some significant performance improvements. The GZIP Page Compression options are located on the Server tab in the Global Configuration Manager.

If you don’t use it, disable it

Disable all Components, Modules and Plugins that you are not using. Even if you are not displaying the output on the page, the system is likely doing at least some of the processing associated with the feature.

Minify your CSS and JavaScript

Minification is the process of reducing the size of CSS selectors and JavaScript by reducing unnecessary spaces and characters. While minifying a single selector saves only a small amount, it all adds up and minifying the entire CSS can result in a meaningful savings. This is a tedious manual process, so if you want to employ this technique I suggest you use one of the many tools designed to make this easier. Run a Google search for “minify CSS” and “minify JavaScript” for lists of options. The Joomla! Extensions Directory also lists several Extensions that can compress your CSS and JavaScript.

Be careful with Google Analytics

Google Analytics, though a wonderful and useful service, can slow down your site. Every page that includes the Analytics code increases your load time as the Analytics script causes the system to wait while it contacts the Google servers. The impact of this varies greatly depending on the time of day, the traffic on your site and the location of your servers.

Be selective about your Template

Your Template developer can have a significant impact on your site performance. Many of the lovely Templates I see in circulation rely heavily upon images to achieve their look and feel. The size of the Templates and the number of HTTP requests they generate are not optimal. Select carefully your Template. Look at the file size, and the quality of the code. You want to select Templates that use CSS, not tables, and those that prefer system text to image usage. Be particularly careful of Templates that use images for the menus, rather than system text and CSS. Not only do these Templates have a negative impact on site performance, but they also tend to be less than optimal from the perspective of both SEO and accessibility.

Be selective about Extensions

Some third party Extensions are incredibly resource-intensive. When you are comparing Components, Modules or Plugins, use YSlow to compare the impact on your page performance and check resource usage on your server. Don’t forget that small differences in performance can balloon into big differences when the site experiences spikes in traffic.

Skip live stat reporting

Components or Modules that produce live real-time statistics on your site can be significant drains on site performance. If you don’t have a compelling need for real-time statistics, skip them.

Disable SEF URLs

Though this may not be an option for many of you, if your goal is performance above all else, disable the SEF URLs option. The conversion of your native URLs into Aliases causes a performance hit.

Optimize your database

One of the main performance bottlenecks for any content management system is the database server. To improve performance, you should periodically optimize the database tables. Optimization is performed from within phpMyAdmin. To learn more about this process, visit the MySQL website.

Filed under: open cms

mathiaslin says...

Since this is a very common feature for many websites, here's a useful snippet I usually use when displaying RSS feeds in an OpenCms template. For example you want to display an Atom RSS feed from a WordPress blog on your OpenCms based website.

My approach is usually:
The OpenCms schema has a OpenCmsString input field (named BlogRssUrl in my case), which is mapped to the property BlogRssUrl as well.

<xsd:complexType name="OpenCmsMySchema">
  ...
  <xsd:element name="BlogRssUrl" type="OpenCmsString" minOccurs="0" maxOccurs="1" />
  ...
</xsd:complexType>

<mappings>
    <mapping element="BlogRssUrl" mapto="property:BlogRssUrl" />
</mappings>

For fetching the RSS feed, I recommend the ROME Fetcher subproject library at https://rome.dev.java.net/, which only depends on the JDOM parser (jdom.jar). So you will end up deploying three additional jars:

  • jdom.jar
  • rome-1.0RC2.jar (or newer version)
  • rome-fetcher-0.9.jar (or newer version)


Below is the scriplet then for the OpenCms jsp template:

<%@ taglib prefix="cms" uri="http://www.opencms.org/taglib/cms" %>
<%@ page session="false" import="org.opencms.jsp.*,java.util.*,org.opencms.file.*,java.net.URL,com.sun.syndication.feed.synd.*,com.sun.syndication.fetcher.*,com.sun.syndication.fetcher.impl.*" %>
<%  
    CmsJspActionElement cms = new CmsJspActionElement(pageContext, request, response);
    String filename = cms.getRequestContext().getUri();

           // === RSS Feed Fetching ===
    FeedFetcherCache feedInfoCache = HashMapFeedInfoCache.getInstance();
    FeedFetcher feedFetcher = new HttpURLFeedFetcher(feedInfoCache);
    CmsObject cmso = cms.getCmsObject();
    String blogRssUrl = cmso.readProperty(filename, "BlogRssUrl");
    SyndFeed feed = null;
    if (blogRssUrl!=null && !"".equals(blogRssUrl)) feed = feedFetcher.retrieveFeed(new URL(blogRssUrl));
%>

and then display the output on the page:

<% if (feed!=null) { %>
<ul>
<%
// === RSS feed output ===
for (Iterator<SyndEntry> iter= feed.getEntries().iterator(); iter.hasNext();) {
    SyndEntry entry = iter.next();
    %>               
    <li>[a href="<%=entry.getUri()%>"]<%=entry.getTitle()%>[/a]</li>                               
    <%               
}
%>
</ul>
<% } %>

Filed under: opencms

mathiaslin says...

I recorded an OpenCms introduction video last weekend using Movie Maker and CamStudio (both free and easy-to-use tools), but still trying to improve the quality. 


This is my very first video recording and cutting, so please be considerate ;) 
Planning to add more videos step by step later. Hope to encourage others to do the same (on complementary topics).

Filed under: opencms

mathiaslin says...

SYSVISION Photoalbum Module integrates SmoothGallery (GPL) into OpenCms as an add-on module package, which allows visitors to experience nicer visual effects on photo display. The module is easy-to-use. Thanks to Jonathan Schmeoul for developing the SmoothGallery in the first place!

To use the SYSVISION Photoalbum module, you need at least OpenCms version 7.0.5.

Please see the SYSVISION_Photoalbum.PDF for details.

Download this module as zip from here: com.sysvision.opencms.frontend.photoalbum_0.2.zip (~ 2.8 MB)

http://www.sysvision.com/opencms/opencms/en/expertise/cms/solutions/photoalbum_module.html

Filed under: opencms

mathiaslin says...

In recent projects we have used the Spring MVC integrated into OpenCms. This topic is not new to the OpenCms community, as it has already been covered a
little in the OpenCms wiki and also Bearingpoint provides an open source submodule in their Commons-Project at Sourceforge.
 
Nevertheless, we make our small 'getting-started' project available now - it's aimed for developers who want to integrate Spring & Hibernate into
OpenCms for the first time and would like to have a ready-to-go starting point/project setup.
The project includes Eclipse and NetBeans project files as well as the ant build file. We used it for OpenCms7.0.5 and OpenCms7.5. With these OpenCms versions, the versions of the depending lib files used by Spring and OpenCms should not
conflict. (We didn't use it with OpenCms6 yet).
 
SVN:
http://svn.sysvision.net:9027/svn/com.sysvision.opencms.spring/
User: anon, Password: anon
 
or download as zip from:
http://www.sysvision.de/en/expertise/cms/solutions/opencms_spring_integration.html
 
The project contains a Readme.pdf how to use it. We hope it's useful to someone and are open for any comments, suggestions and improvements.
 
(A note regarding Hibernate: we don't use the OpenSessionInViewPattern (OSIV), so you won't find it in the project. If you want/need it, you will
find infos about it in the opencms-wiki.org)

Filed under: opencms

mathiaslin says...

When exporting the Formgenerator data to CSV, there might be some problems with exporting numbers and trailing zeros when opening the file in Excel. I.e. if you have a column with zip codes and some values start with 0, they will get lost in Excel. Also, when exporting large numbers, Excel usually displays them withe the +E syntax.
 
To avoid it, the csv should escape such numbers with a = in front of it, i.e.the CSV should read:
,="07635",
 
We modified the class com.alkacon.opencms.formgenerator.database.export.CmsCvsExportBean.java, method escapeExcelCsv: checking if the value can be parsed as Double or Long, if so, put an = in front of the escaped value.
(The = cannot be put in front of all types of fields; if put in front of an escaped string value that contains commas, it will break the format; so we
really need to check if it's a number value).


/**
* Escapes CSV values for excel.<p>
*
* @param value the value to escape
*
* @return the escaped excel value.
*/
private String escapeExcelCsv(final String value) {
// Begin: SYSVISION modification
boolean isNumber=false;
try {Long.valueOf(value);isNumber=true;} catch (Exception e) {};
try {Double.valueOf(value);isNumber=true;} catch (Exception e) {};
// End: SYSVISION modification

String result = value;
StringBuffer buffer = new StringBuffer();
buffer.append("\"");
char[] chars = value.toCharArray();
for (int i = 0; i < chars.length; i++) {
// escape double quote escape delimiter within value:
if ('"' == chars[i]) {
buffer.append("\"");
}
buffer.append(chars[i]);
}
buffer.append("\"");
result = buffer.toString();
return (isNumber?"=":"") + result; // SYSVISION modification
}

Filed under: opencms