Among the problems that are the hardest to diagnose in a web application installation are performance issues. They may arise from either software issues, a back-end system that is not behaving as expected, a network issue or any other internal or external factor (don't forget to check available disk space :)). Fortunately there are a lot of different tools available, ranging from built-in JVM tools to Java Profilers. Java Profilers are usually a "last resort" type of solution, as they are the tools that have the most effect on performance, but when all other tools have failed to properly diagnose a problem, usually the profiler should raise the issues properly. We at Jahia have been using for a long time the YourKit Java Profiler. It was initially designed to be used in pre-production systems and we have used it successfully even when benchmarking our software under high loads. Of course the profiler has an impact on performance (and also on memory usage), but if well configured, these may be controlled and taken into account. Quick disclaimer In this guide we will talk about some of the important options used to diagnose performance issues on pre-production or production systems,

  On Monday, January 16th, OASIS will organize the first conference call to elect a chair for the new Web Experience Management Interoperability (WEMI) Technical Committee (TC). This new TC was announced last November in the aim of defining a standard around the ideas of Web Experience Management (also known as WEM). The Web Experience Management Interoperability standard is both a mouthful and an ambitious goal, and I'd like, in this article, to talk a little about my views of why this standard is needed and what I hope it may become. Ever since Tim Berners-Lee (http://www.w3.org/People/Berners-Lee/) invented the Web at CERN (http://www.cern.ch), the idea of how to integrate complex and distant systems has been in the air. Actually for the old-timers, some of this can be traced back quite far, back to DCE (http://en.wikipedia.org/wiki/Distributed_Computing_Environment or CORBA (http://en.wikipedia.org/wiki/CORBA) standard, where the idea of interacting with distant software was first introduced. The birth of the web brought a new interesting concept to remoting, the idea that what we actually want to publish and interact no longer with pure application logic but with content. Of c

If you're like me, you might need to test compatibility with Java 1.5 despite the fact that it's old and that nobody should use it anymore :) Unfortunately the reality is that some users migrate slowly, and so it might be useful to be able to test with old versions of the JDK. As you probably know, the JDK 1.5 is not available officially for Mac OS X Lion. But there is a way to install it anyway, and it is very well documented here : http://www.s-seven.net/java_15_lion Let me know if you liked this tip, I might add more in the future :)

  This post has been written by: Glenn Korban – Director of Technology - Oshyn Glenn's Bio: As a technical architect on the Oshyn team, Glenn specializes in delivering interactive enterprise solutions leveraging WCM technologies, custom Web-app development, and Agile development methodologies. With 9 years of experience in software development, Glenn has worked in fields such as entertainment, finance, automotive, and some top-secret defense and intelligence stuff we can’t talk about (or we’d have to…well, you know).  Although Glenn is at home with a wide variety of technologies and platforms; his weapon of choice is Java development using open-source technologies. When not heads-down on his computer, Glenn spends his time outside skiing and rock climbing. With all the new features available in Jahia’s 6.5 release, I decided to put together a list of my Top 5 most exciting new features.  As a matter of full disclosure, my personal bias in choosing my Top 5 exciting features in Jahia 6.5, is geared toward those features I think can best help our development team deliver high value features for our clients and deliver solutions as efficiently and cost-effectively as possible.  Sure,

  An interview from Emmanuel Garcin, VP and General Manager of Jahia Americas. Hi Emmanuel, it sounds like there's a lot of excitement among your clients and integration partners over Jahia's new composite content platform, currently in beta. Why is version 6.5 a big deal? Emmanuel Garcin: Version 6.5 is a big deal for several reasons. Above all, I'd say that our new release will make module creation easier than ever before - more like a PHP solution such as Drupal -- which is unheard of among Java platforms. What do you mean by "next generation web content management"? Emmanuel Garcin: The "next generation" tag isn't of our making. As per Forrester's Stephen Powers: "IBM is betting that the WCM and portal markets will converge and cease to be separate markets, with vendors offering combined WCM/portals suites that have on administrative tool set, one presentation management structure, one repository, and so on." Gene Phifer, of Gartner adds: "The user experience platform (UXP) will allow enterprise developers and end users to create cross-platform user interfaces via a single set of integrated technologies, tying together disparate tools for the creation of websites, portals, mash

  Recently, an article on CMSWire caused quite a stir, mostly because it was asking the controversial question "Is the JCR dead ?". In reply, a few opinions posted by myself and other CMS actors/vendors were quick to appear, but I think some clarification is needed in order to explain what I think is really relevant for developers, integrators and end-users. The quick answer is : neither JCR nor CMIS are really important for end-users. Fortunately most of them will never have to deal with either, and only integrators and developers will have to bother. Now these two standards were put in opposition in the article, probably in the hope that the controversy would attract readers, but it actually doesn't make sense to do that. A lot of developers are actually using both, and the only real difficulty in integrating the two is translating queries, but apart from that it maps pretty well. The JCR is not dead and still relevant, because other standards such as JDBC are not dead and also still relevant. A lot of people wanting to see the JCR die have probably had bad experiences with it, or have moved on to other technologies, but this standard still make a lot of sense in the Java CMS and

  I often get the question of why open source code is important, aside from the usual benefits of code review, security auditing, and the general idea that more eyeballs makes for better implementations ? Well, where it really shines is during support, when you are investigating a bug. Let's say that you have a bug, and that for once it is not in your code. It seems to come from some library that is used by your software. When this happens, for example when I'm working on an iPhone application, it usually takes a long time to find the method responsible for the bug. If the libraries are closed-source, this time can be made longer simply by the fact that you are not sure what the dependencies between libraries are, and can spent time trying to pin-point the location of the problem. Once you have managed to track it, all you can do is file a bug report to the author, and hope it will be adressed. In this example case of an iPhone application, this might be a long time, if ever it gets fixed (as bugs are proritized by project managers). In the case of an open source product, such as Jahia, you have the full source code, and you are free to modify it for your own means, or redistribute

  I was going through some CMS and portal software implementations yesterday, and looked at them from a standards point of view. You might wonder, why are standards important ? Isn't it easier to build something minimal that will do just the job ? Well in terms of software engineering it probably seems to be, but you end up in a very proprietary system, but using standards don't necessarily mean that you will have to build more code.  One standard comparison that is often mentioned nowadays is the one between SQL andCMIS. Some call CMIS the "SQL for content", while others (like my good colleague Stéphane) view it more as the SQL for file systems :) But anyway, what do these standards really bring us, except for the hassle of implementing them and even harder testing interoperability ?  I think one of the best examples in this area is what has happened in the browser world. They would have never existed if it wasn't for standards. When Mozilla was started, there wasn't really a standard for HTML, it was written based on the implementation, but that's ok. When Mozilla became Netscape, it added a lot of extensions to HTML, like layers, that weren't part of the standard, and when Inter