[About cuncurrency:] My problem with the functional programming cure to this problem is that I haven’t seen a cure yet that’s better than the problem. Maybe it’s me. Maybe my tiny Ben brain just can’t comprehend the magic and majesty of OCaml, but every time I’ve tried to learn a new functional language, it’s ended it disaster. First with Erlang, and then Haskell, I’ve now had two aborted attempts to understand the supposed cure to the concurrency problem. The languages are just too complex, too terse, and absolutely full of academic shitheaddery. I mean, seriously, what the hell.

that really made my morning

http://www.benrady.com/2010/06/a-bit-of-heresy-functional-languages-are-overrated.html

The reason is simple, I sometime would like to post in French but this would rather spoil codesmell (which is in English at 99% with a rather strong German audience).

As such, I’m now sitting on joseph on IT (sorry for the name, but I’m really bad at such kind of naming).

thanks a lot to all of you and esp. to uwe for his warm welcome and constant care.

luckily, the web is a cosy place, we won’t loose touch too much

++
joseph

If you´re into eclipse and do occasional javascript and maybe jquery or <put your fav javascript lib here>, you should definitly have a look at Aptana Studio. Note, that – if you really wanted – you can also get it as a standalone editor.

The story is this: at some point, they tried to branch their code, usually so that the shipping version which they gave their customers can be branched off separately from the version that the developers are playing with. And every team has told me that when they tried this, it worked fine, until they had to merge, and then it was a nightmare. What should have been a five minute process ended up with six programmers around a single computer working for two weeks trying to manually reapply every single bug fix from the stable build back into the development build.

And almost every Subversion team told me that they vowed “never again,” and they swore off branches. And now what they do is this: each new feature is in a big #ifdef block. So they can work in one single trunk, while customers never see the new code until it’s debugged, and frankly, that’s ridiculous.

to explaining the simple commands, and further to conceptual perspectives like repository distribution.

a nice read.

So true !

++

Small post to tell that I’ve started to look into SCJD, another certification. As such, I fear I will once again post way less (in case anyone cared, which might be quite optimistic, yes I know, thanks ).

Anyway, not to do a totally useless entry, let’s share a few links :

• a nice reference diagrams about design patterns. For once a design patterns reference one can finish before falling asleep ^^
• a nice recap of sql joins (provided, surprise !, by our dear admin)
• if ever you (too) stumbled upon Hibernate not escaping tables’ and columns’ names when creating the database, some explanations and work around: Escaping database column name when using Hibernate
• to finish on a lighter note, for clueless foreigners working in Germany, some info about the Bielefled conspiracy.Hopefully the blog won’t be taken down !

see ya !
++

The authors make clear at the beginning that the book is about, and only about, being ready for the SCJP exam. No more, no less. And they keep to their words : the book is strictly focused on the exam.

The bad consequence is that sometime (often) I was eager to know more, to go further the “there’s plenty more to tell, but that’s enough for the exam, so we stop here”. Furthermore, as you can imagine, this isn’t the most fancy book I’ve ever read. Katherine and Bert do attempt a few times to instil some fun, but it didn’t fall quite right.

The very good side is that the book teaches all you need to know, no more, no less. I would even go a bit further : if the authors say “methods X and Y are also part of the exam”, then you should really know exactly what’s in these methods. I’m pretty sure I lost some points due to some API I didn’t know enough. Even better, they say clearly what’s in the exam and not. No need to worry because some dumb mock exams found on the web put stuff you hadn’t any clue off. If it wasn’t in the book, it’s not on the exam.
Even more important, the writers are very good at explanations. Really, they know out to make things clear. Awesome. I now have a grip on regexp. Really !

To conclude, this book is really one (if not the one – I haven’t read the others so it’s hard to tell) to go for when preparing SCJP 6, no more, no less. At least it was for me!

++

EDIT : did a bit of clean-up

We’re delighted to introduce a new wicket component which will allow you to easily integrate Google Waves right into your application. Please meet GoogleWavePanel !
The idea of making this component came from a recent tutorial which aimed at clarifying the use of Google’s Wave Embed API.

http://blog.zenika.com/index.php?post/2010/02/03/Surf-the-Wave-with-Wicket-and-the-GoogleWavePanel

On the other hand, Steve Krug’s Don’t make me think is still deeply in my mind. Not only the author applied usability to his book (about 200 pages, very easy to read with drawings right to the point), but, even better, what he wrote is enlightening.

First, Steve Krug introduces the “guiding principles”, all evolving around his First Law of Usability : Don’t make me think. Simply put, the aim is to remove all questions, even unconscious ones, when browsing the web. All these littles inconveniences or inconsistencies which go in the way must disappear. And Steve Krug presents this with way more skills and drawings than I do, making it really impressive and long lasting.

He goes on speaking on the way we use the web (scanning, not reading), than that we should “Omit needless words”.

These first chapters are still vivid in my mind. They come with very relevant examples that we’ve all seen before, and thus that we’ll see again in the future, bringing back the good stuff of this book.

Then, Steve Krug goes on a more general level : why/how to avoid these endless discussions about “mine design is better than yours”, how to do “real size” usability tests (and not the ones requiring huge resources/teams/testers/rooms/… as was put in this previous book!) and how to deal with Pointy-Haired Bosses. Less crazy than the first chapters, but really helpful.

Overall, this book really helped me. I now have quite a tool set (and mindset) to deal with usability questions. To put it shortly, I feel now empowered on this topic, quite a change from my previous readings.

To conclude, if usability is remotely some of your concern (and you don’t know it all already), read this book !

++
joseph

Yet, for some reasons I don’t get, these functionalities aren’t much advertised. Anyway, let’s dig in !

Basically, this templating is about some text containing variables, for example ${variable}, whose values are provided through Java code.

Let’s take a simple example, a template file named javascript.tpl containing :

alert('${variable}');

Wicket is nice enough to provide an easy to access the templates as package resources, through the PackagedTextTemplate class :

public PackagedTextTemplate(final Class clazz, final String fileName)

For example :

PackagedTextTemplate jsTemplate = new PackagedTextTemplate(this.getClass(), "javascript.tpl");

Thus the template can be next to the .html page and the Java class using it, making the whole quite cohesive.

Providing the variables is done through a simple Map :

Map parameters = new HashMap();
parameters.put("variable","test working");</code>

• as an header contribution :
  

  add(TextTemplateHeaderContributor.forJavaScript(jsTemplate, new  Model((Serializable) parameters)));
  

• directly next to some element in the html file:
  Java side :
  

  Label myScript = new Label("myScript", new JavaScriptTemplate(jsTemplate).asString(parameters));
  myScript.setEscapeModelStrings(false);
  add(myScript);
  

  Html side :
  

  <wicket:container wicket:id="myScript"></wicket:container>
  

You may have noticed that, in both cases, I didn’t provided the surrounding script tag (and the appropriate inner wrapping). Fear not, Wicket does it for you !
Indeed, the rendered html is :

<script type="text/javascript">
alert('test working');
</script>

If the template was about some CSS stuff, one would just need to warp it using a CssTemplate instead of the JavaScriptTemplate.

A bit more info are available there Including CSS resources.

++
joseph

    public static Object[] convertPrimitiveArray(final Object array)
    {
        final int arrayLength = Array.getLength(array);
        final Object[] result = (Object[]) Array.newInstance(Object.class, arrayLength);
        for (int i = 0; i < arrayLength; i++)
        {
            Array.set(result, i, Array.get(array, i));
        }
        return result;
    }

• Go to your workspace folder
• in the folder .metadata/.plugins/org.maven.ide.eclipse, remove all file ending with .container
• in eclipse, clear all projects
• hope for the best

For us, it has resolved a nasty issue we had : some projects’ dependencies weren’t resolved locally even if the projects in question were in the workspace.

Hope it helps

++

<img src="http://example.com/images/someimage.jpg" style="background-image:url('style/spinner.gif');" />

Assuming the local machine is faster than the external server, the
spinner should be visible while the external image loads.

Martijn

I’ve recently read Test-Driven Development By Example, a book from Kent Beck.

I’ve liked the following:

• description of the TDD cycle : Red – write a little failing test/Green – make the test pass quickly, even if it involves dirty tricks or duplication/Refactor – make the code clean, including hunting for duplicates for example.

  The emphasis on making the test working quickly first was a bit unexpected to me. Indeed, I tend to try to write “clean code” first. It’s not bad in itself, but it happens sometime that I’m not confident with the design. Thus, I feel uneasy. Smaller steps, maybe less clean, would probably help: seeing a green bar is always a good feeling. This leads me to the next point.

• Kent writes that one of the key point of TDD is about reducing stress : being able to do small steps reduces the stress/fear level, hence fewer errors and better feeling. If the target design is unknown or intimidating, use (very) small steps.

  As pointed before, I wasn’t really aware of this, even if I appreciated the final feeling one has after writing proper unit tests. I’ll try it

• The notion of “emerging/organic” design is as well spoken of. It’s the idea that with proper TDD the design will evolve to fit exactly the needs, no more, no less. A kind of perfect match in the end.

  I had already heard of it but it was a nice refresher. Still, it doesn’t fit with our actual practices : we tend to prototype first the design.

  But maybe once I should try starting with a very easy and naive implementation and see where it goes. After a few refactorings, it may end at the same design, or may be even better. Still, I fear it would take more time and I’m unsure about the results.

  On the other hand, as told by Kent, if ever the code has to evolve to become more general, this can be done easily, with the tests providing the required safety net. Then, how many code are designed with a way broader scope that they’ll actually use, leading to verbose and/or a bit inappropriate abstractions ?

  Once again, feedback is welcome, and anyway I’ll test it.

• TDD helps narrowing and keeping focus. That’s a big reason for the small steps, one thing at a time, so if something behaves in a unexpected way it’s easy to spot early.

  But Kent pushes it further : when doing TDD and using “dirty tricks” to get the green bar, he suggests writing done a list of the stuff left to do. He does so as well for other related ideas popping up. The aim is to keep focus on the current work, coming back later on the todo/improvements noted (which in turn, for sure, can/should be done test first ). He suggests using a good old paper list, and simply to strike the work done. As such, progress can be seen easily and is quite satisfactory. Furthermore, the overview is always present and one can easily pick the easiest/smallest stuff to do, for example just before leaving.

  Said this way, it may sound obvious, but the fact is that we tend to lost focus when doing pair programming. Maybe Pomodoro could help us, but this way of doing as well. Again, it’s worth a try !

Still, the book wasn’t only joy to read. The first 80 pages are a TDD example where Kent Beck uses very small steps. Personally, it really went on my nerves. Furthermore, he complains about some lack of features in Java which have been added since (the book is from 2003). It didn’t help neither.

He finishes the book with a small chapters on different patterns, like “red bar”, “green bar” , testing, xUnit, design and refactoring. If you have a bit of practices regarding unit testing and if you have knowledge on patterns and refactoring (personally I’ve read books like Refactoring and Head First Design Patterns), there is few to learn there. Only the null pattern did interest me and will be the topic of another post. I wish he has spent more time on testing, like which code coverage to aim for (and why), gui unit testing and common pitfalls.

Maybe some answers lie in the “Testing Object Oriented Systems: Models, Patterns, and Tools” which he presents as “the comprehensive reference on testing”. This time is a 1000 pages book, sounds intriguing lol

++

Side note : I often wonder if my reviews aren’t too verbose… I would welcome feedback on the matter !

We were some time ago at a presentation about hibernate (at a Karlsruhe JUG event). The presenter, Michael Plöd showed us a nice Hibernate statistics page. As you can bet, we went for reusing it

However, in doing so, some issues appeared, and in the end we thought the updated version could be useful for others as well.

It mainly consists in an adaptation to Wicket 1.4 (generics).

In details, the changes are :
- use of ReloadableDetachableModel, needed AFAIK by Hibernate statistics (they have transient fields in their objects, and as such I was getting NPE after refreshing the page),
- page completely “genericfied” : compact code, no more cast or compiler warning (the page was written for wicket 1.3 I presume),
- minor display issues fixed : date showed as a formatted date, executionMinTime’s default value (Long.MAX_VALUE) taken in account (and replace by zero),
- html closer from the “standards” : use of h1, thead and the like (which we use in our template, so…),
- in order to make the component injection independent, there is now a setter for the entity manager provider (consequently the actual page construction is made in “onBeforeRender”),
- the code is now in a panel, so it can be easily put in any application specific page.

Whatever, the code, quite long long, is following.

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;

import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.link.Link;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.AbstractReadOnlyModel;
import org.apache.wicket.model.CompoundPropertyModel;
import org.apache.wicket.model.LoadableDetachableModel;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.stat.CollectionStatistics;
import org.hibernate.stat.EntityStatistics;
import org.hibernate.stat.QueryStatistics;
import org.hibernate.stat.SecondLevelCacheStatistics;
import org.hibernate.stat.Statistics;

public class HibernateStatisticsPanel extends Panel
{
    private static final String DATE_FORMAT = "hh'h'mm dd.yy.MM";

    private EntityManager entityManager;

    private static DateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);

    public HibernateStatisticsPanel(final String id)
    {
        super(id);
    }

     @Override
    protected void onBeforeRender()
    {
        if (!hasBeenRendered())
        {
            if (entityManager == null)
            {
                throw new IllegalStateException("The entityManagerProvider must be set.");
            }
            final CompoundPropertyModel model = new CompoundPropertyModel(
                    new LoadableDetachableModel()
                    {
                         @Override
                        protected Statistics load()
                        {

                            return getSessionFactory(entityManager).getStatistics();
                        }
                    });
            setDefaultModel(model);

            add(new Label("isStatisticsEnabled", new LoadableDetachableModel()
            {

                 @Override
                protected String load()
                {
                    String result;
                    if (areStatsEnabled() == true)
                    {
                        result = "enabled" + " since " + dateFormat.format(new Date(model.getObject().getStartTime()))
                                + " (" + DATE_FORMAT + ")";
                    }
                    else
                    {
                        result = "disabled";
                    }
                    return result;
                }

            }));

            Link switchStats = new Link("switch_stats")
            {
                 @Override
                public void onClick()
                {
                    final SessionFactory sessionFactory = getSessionFactory(entityManager);
                    sessionFactory.getStatistics().setStatisticsEnabled(
                            !sessionFactory.getStatistics().isStatisticsEnabled());
                    sessionFactory.getStatistics().clear();
                    final CompoundPropertyModel model = new CompoundPropertyModel(
                            new LoadableDetachableModel()
                            {
                                 @Override
                                protected Statistics load()
                                {
                                    return sessionFactory.getStatistics();
                                }
                            });
                    setDefaultModel(model);
                }
            };
            switchStats.add(new Label("switchText", new LoadableDetachableModel()
            {

                 @Override
                protected String load()
                {
                    if (areStatsEnabled())
                    {
                        return "Click to disable stats";
                    }
                    return "Click to enable stats";
                }
            }));
            add(switchStats);

            add(new Label("sessionOpenCount"));
            add(new Label("sessionCloseCount"));
            add(new Label("flushCount"));
            add(new Label("connectCount"));
            add(new Label("prepareStatementCount"));
            add(new Label("closeStatementCount"));
            add(new Label("entityLoadCount"));
            add(new Label("entityUpdateCount"));
            add(new Label("entityInsertCount"));
            add(new Label("entityDeleteCount"));
            add(new Label("entityFetchCount"));
            add(new Label("collectionLoadCount"));
            add(new Label("collectionUpdateCount"));
            add(new Label("collectionRemoveCount"));
            add(new Label("collectionRecreateCount"));
            add(new Label("collectionFetchCount"));
            add(new Label("secondLevelCacheHitCount"));
            add(new Label("secondLevelCacheMissCount"));
            add(new Label("secondLevelCachePutCount"));
            add(new Label("queryExecutionCount"));
            add(new Label("queryExecutionMaxTime"));
            add(new Label("queryExecutionMaxTimeQueryString"));
            add(new Label("queryCacheHitCount"));
            add(new Label("queryCacheMissCount"));
            add(new Label("queryCachePutCount"));
            add(new Label("commitedTransactionCount"));
            add(new Label("transactionCount"));
            add(new Label("optimisticFailureCount"));

            ListView entityStats = new ListView("entities",
                    new LoadableDetachableModel< List  >()
                    {

                         @Override
                        protected List load()
                        {
                            String[] entities = model.getObject().getEntityNames();
                            List entityNames = new ArrayList();
                            for (int i = 0; i < entities.length; i++)
                            {
                                entityNames.add(model.getObject().getEntityStatistics(entities[i]));
                            }
                            return entityNames;
                        }
                    })
            {
                 @Override
                protected void populateItem(final ListItem item)
                {
                    item.setModel(new CompoundPropertyModel(item.getModelObject()));

                    item.add(new Label("deleteCount"));
                    item.add(new Label("updateCount"));
                    item.add(new Label("fetchCount"));
                    item.add(new Label("insertCount"));
                    item.add(new Label("loadCount"));
                    item.add(new Label("optimisticFailureCount"));
                    item.add(new Label("categoryName"));
                }
            };
            add(entityStats);

            ListView collectionStats = new ListView("collections",
                    new LoadableDetachableModel()
                    {

                         @Override
                        protected List load()
                        {
                            String[] collections = (model.getObject()).getCollectionRoleNames();
                            List collectionNames = new ArrayList();
                            for (int i = 0; i < collections.length; i++)
                            {
                                collectionNames.add(model.getObject().getCollectionStatistics(collections[i]));
                            }
                            return collectionNames;
                        }
                    })
            {
                 @Override
                protected void populateItem(final ListItem item)
                {
                    item.setModel(new CompoundPropertyModel(item.getModelObject()));

                    item.add(new Label("recreateCount"));
                    item.add(new Label("updateCount"));
                    item.add(new Label("fetchCount"));
                    item.add(new Label("removeCount"));
                    item.add(new Label("loadCount"));
                    item.add(new Label("categoryName"));
                }
            };
            add(collectionStats);

            ListView queryStats = new ListView("queries",
                    new LoadableDetachableModel< List  >()
                    {

                         @Override
                        protected List load()
                        {
                            String[] queries = (model.getObject()).getQueries();
                            List queryNames = new ArrayList();
                            for (int i = 0; i < queries.length; i++)
                            {
                                queryNames.add(model.getObject().getQueryStatistics(queries[i]));
                            }
                            return queryNames;
                        }
                    })
            {
                 @Override
                protected void populateItem(final ListItem item)
                {
                    item.setModel(new CompoundPropertyModel(item.getModelObject()));

                    item.add(new Label("cacheHitCount"));
                    item.add(new Label("cacheMissCount"));
                    item.add(new Label("cachePutCount"));
                    item.add(new Label("executionCount"));
                    item.add(new Label("executionRowCount"));
                    item.add(new Label("executionAvgTime"));
                    item.add(new Label("executionMaxTime"));
                    item.add(new Label("executionMinTime", new AbstractReadOnlyModel()
                    {

                         @Override
                        public String getObject()
                        {
                            // by default the hibernate stats. object put
                            // Long.MAX_VALUE to the executionMinTime, so we
                            // look for it and replace it by 0 where needed
                            long executionMinTime = item.getModelObject().getExecutionMinTime();
                            if (executionMinTime == Long.MAX_VALUE)
                            {
                                return "0";
                            }
                            return "" + executionMinTime;
                        }
                    }));
                    item.add(new Label("categoryName"));
                }
            };
            add(queryStats);

            ListView cacheStats = new ListView("caches",
                    new LoadableDetachableModel< List  >()
                    {
                         @Override
                        protected List load()
                        {
                            String[] caches = model.getObject().getSecondLevelCacheRegionNames();
                            List cacheNames = new ArrayList();
                            for (int i = 0; i < caches.length; i++)
                            {
                                cacheNames.add(model.getObject().getSecondLevelCacheStatistics(caches[i]));
                            }
                            return cacheNames;
                        }
                    })
            {
                 @Override
                protected void populateItem(final ListItem item)
                {
                    item.setModel(new CompoundPropertyModel(item.getModelObject()));

                    item.add(new Label("hitCount"));
                    item.add(new Label("missCount"));
                    item.add(new Label("putCount"));
                    item.add(new Label("elementCountInMemory"));
                    item.add(new Label("elementCountOnDisk"));
                    item.add(new Label("sizeInMemory"));
                    item.add(new Label("categoryName"));
                }
            };
            add(cacheStats);

        }
        super.onBeforeRender();
    }

    private boolean areStatsEnabled()
    {
        return ((Statistics) getDefaultModelObject()).isStatisticsEnabled();
    }

    public static SessionFactory getSessionFactory(final EntityManager entityManager)
    {
        Object delegate = entityManager.getDelegate();
        if (delegate instanceof Session)
        {
            Session session = (Session) delegate;

            return session.getSessionFactory();
        }
        return null;
    }

    public void setEntityManager(final EntityManager entityManager)
    {
        this.entityManager = entityManager;
    }

    public EntityManager getEntityManager()
    {
        return entityManager;
    }
}

And the html page :

<html>
     <wicket:panel>
              <h1>Hibernate Statistics</h1>
               Statistics are <span wicket:id="isStatisticsEnabled"/>.<br /> <a href="#" wicket:id="switch_stats"><span wicket:id="switchText"></span></a>
     <br /><br />
     <h2>Overview</h2>
    <table class="whiteGrey">
        <tr><th>sessionOpenCount</th><td><span wicket:id="sessionOpenCount"/></td></tr>
        <tr><th>sessionCloseCount</th><td><span wicket:id="sessionCloseCount"/></td></tr>
        <tr><th>flushCount</th><td><span wicket:id="flushCount"/></td></tr>
        <tr><th>connectCount</th><td><span wicket:id="connectCount"/></td></tr>
        <tr><th>prepareStatementCount</th><td><span wicket:id="prepareStatementCount"/></td></tr>
        <tr><th>closeStatementCount</th><td><span wicket:id="closeStatementCount"/></td></tr>
        <tr><th>entityLoadCount</th><td><span wicket:id="entityLoadCount"/></td></tr>
        <tr><th>entityUpdateCount</th><td><span wicket:id="entityUpdateCount"/></td></tr>
        <tr><th>entityInsertCount</th><td><span wicket:id="entityInsertCount"/></td></tr>
        <tr><th>entityDeleteCount</th><td><span wicket:id="entityDeleteCount"/></td></tr>
        <tr><th>entityFetchCount</th><td><span wicket:id="entityFetchCount"/></td></tr>
        <tr><th>collectionLoadCount</th><td><span wicket:id="collectionLoadCount"/></td></tr>
        <tr><th>collectionUpdateCount</th><td><span wicket:id="collectionUpdateCount"/></td></tr>
        <tr><th>collectionRemoveCount</th><td><span wicket:id="collectionRemoveCount"/></td></tr>
        <tr><th>collectionRecreateCount</th><td><span wicket:id="collectionRecreateCount"/></td></tr>
        <tr><th>collectionFetchCount</th><td><span wicket:id="collectionFetchCount"/></td></tr>
        <tr><th>secondLevelCacheHitCount</th><td><span wicket:id="secondLevelCacheHitCount"/></td></tr>
        <tr><th>secondLevelCacheMissCount</th><td><span wicket:id="secondLevelCacheMissCount"/></td></tr>
        <tr><th>secondLevelCachePutCount</th><td><span wicket:id="secondLevelCachePutCount"/></td></tr>
        <tr><th>queryExecutionCount</th><td><span wicket:id="queryExecutionCount"/></td></tr>
        <tr><th>queryExecutionMaxTime</th><td><span wicket:id="queryExecutionMaxTime"/></td></tr>
        <tr><th>queryExecutionMaxTimeQueryString</th><td><span wicket:id="queryExecutionMaxTimeQueryString"/></td></tr>
        <tr><th>queryCacheHitCount</th><td><span wicket:id="queryCacheHitCount"/></td></tr>
        <tr><th>queryCacheMissCount</th><td><span wicket:id="queryCacheMissCount"/></td></tr>
        <tr><th>queryCachePutCount</th><td><span wicket:id="queryCachePutCount"/></td></tr>
        <tr><th>commitedTransactionCount</th><td><span wicket:id="commitedTransactionCount"/></td></tr>
        <tr><th>transactionCount</th><td><span wicket:id="transactionCount"/></td></tr>
        <tr><th>optimisticFailureCount</th><td><span wicket:id="optimisticFailureCount"/></td></tr>           
    </table>
    
    <h2>Entity Statistics</h2>
    <table class="whiteGrey">
        <thead>
             <tr>
                 <th>Entity</th>
                 <th>Load Count</th>
                 <th>Fetch Count</th>
                 <th>Insert Count</th>
                 <th>Delete Count</th>
                 <th>Update Count</th>
                 <th>Optimistic Failure Count</th>
               </tr>
        </thead>
          <tbody>
            <tr wicket:id="entities">
                <td><span wicket:id="categoryName"/></td>
                <td><span wicket:id="loadCount"/></td>
                <td><span wicket:id="fetchCount"/></td>
                <td><span wicket:id="insertCount"/></td>
                <td><span wicket:id="deleteCount"/></td>
                <td><span wicket:id="updateCount"/></td>
                <td><span wicket:id="optimisticFailureCount"/></td>
            </tr>
          </tbody>               
    </table>
    
    <h2>Collection Statistics</h2>
    <table class="whiteGrey">
        <thead>
             <tr>
                 <th>Collection</th>
                 <th>Load Count</th>
                 <th>Fetch Count</th>
                 <th>Recreate Count</th>
                 <th>Remove Count</th>
                 <th>Update Count</th>
               </tr>
        </thead>
          <tbody>
            <tr wicket:id="collections">
                <td><span wicket:id="categoryName"/></td>
                <td><span wicket:id="loadCount"/></td>
                <td><span wicket:id="fetchCount"/></td>
                <td><span wicket:id="recreateCount"/></td>
                <td><span wicket:id="removeCount"/></td>
                <td><span wicket:id="updateCount"/></td>
            </tr>
          </tbody>
    </table>
    
    <h2>Query Statistics</h2>
    <table class="whiteGrey">
        <thead>
             <tr>
                 <th>Query</th>
                 <th>Execution Count</th>
                 <th>Execution Row Count</th>
                 <th>Avg Time</th>
                 <th>Min Time</th>
                 <th>Max Time</th>
                 <th>Cache Hit Count</th>
                 <th>Cache Miss Count</th>
                 <th>Cache Put Count</th>
               </tr>
          </thead>
          <tbody>
            <tr wicket:id="queries">
                <td><span wicket:id="categoryName"/></td>
                <td><span wicket:id="executionCount"/></td>
                <td><span wicket:id="executionRowCount"/></td>
                <td><span wicket:id="executionAvgTime"/></td>
                <td><span wicket:id="executionMinTime"/></td>
                <td><span wicket:id="executionMaxTime"/></td>
                <td><span wicket:id="cacheHitCount"/></td>
                <td><span wicket:id="cacheMissCount"/></td>
                <td><span wicket:id="cachePutCount"/></td>
            </tr>
          </tbody>
    </table>
    
    <h2>Cache Statistics</h2>
    <table class="whiteGrey">
         <thead>
             <tr>
                 <th>Cache</th>
                 <th>Hit Count</th>
                 <th>Miss Count</th>
                 <th>Put Count</th>
                 <th>Elements in Memory</th>
                 <th>Elements on Disk</th>
                 <th>Size in Memory</th>
             </tr>
          </thead>
          <tbody>               
            <tr wicket:id="caches">
                <td><span wicket:id="categoryName"/></td>
                <td><span wicket:id="hitCount"/></td>
                <td><span wicket:id="missCount"/></td>
                <td><span wicket:id="putCount"/></td>
                <td><span wicket:id="elementCountInMemory"/></td>
                <td><span wicket:id="elementCountOnDisk"/></td>
                <td><span wicket:id="sizeInMemory"/></td>
            </tr>
          </tbody>
    </table>
     </wicket:panel>
</html>

The guicy one is as simple as :

import javax.persistence.EntityManager;

import org.apache.wicket.markup.html.panel.Panel;

import com.google.inject.Inject;

public class GuicyHibernateStatisticsPanel extends Panel
{

     @Inject
    private EntityManager entityManager;

    public GuicyHibernateStatisticsPanel(final String id)
    {
        super(id);
        HibernateStatisticsPanel statisticsPanel = new HibernateStatisticsPanel("hibernateStatisticsPanel");
        statisticsPanel.setEntityManager(entityManager);
        add(statisticsPanel);
    }

}

and :

<html>
     <body>
          <wicket:panel>
               <wicket:container wicket:id="hibernateStatisticsPanel" />
          </wicket:panel>
          
     </body>
</html>

Hope it helps
++

PS : I know the html code isn’t shown as best as it could, but I was fed up of trying to get wordpress to render the tags…

Creates an image that is rendered by the Gravatar online service. Gravatars are user
icons that are registered by a central server and that can be used across the
internet with blogs, forums and other profile based websites.

The Gravatar requires the email address for which the gravatar image
needs to be rendered (each gravatar account can have multiple email addresses
registered).

Available options:

• you can set the {@linkplain #setSize(int) size of the rendered image}
• you can pick a {@linkplain #setRating(String) rating} for the intended
  audience
• you can set the {@linkplain #setDefaultImage(String) default image} that
  is rendered when no gravatar was found with the provided email address
• you can choose to use a {@linkplain setSecure secure https protocol or
  plain http}
• the gravatar supports both the {@link #setAlt(IModel) alt} and
  {@link #setTitle(IModel) title} attributes

Set the static fields if you want to modify the defaults for your whole
application.

@author dashorst

http://gist.github.com/266444

What’s the best practice when using generics with models that take some
object but return another type of object?

examples:
When you have a collection and need to convert it to a list for listview
purposes.

to which mighty Igor replied:

/**
 * Simplifies implementing wrapper models that adapt from model object of one type to another
 *
 * @author igor.vaynberg
 *
 * @param 
 *            new type
 * @param 
 *            old type
 */
public abstract class AdapterModel implements IModel
{
    private static final long serialVersionUID = 1L;

    /** delegate model */
    private final IModel delegate;

    /**
     * Constructor
     *
     * @param delegate
     *            model to be wrapped
     */
    public AdapterModel(IModel delegate)
    {
        this.delegate = delegate;
    }

    /** {@inheritDoc} */
    public N getObject()
    {
        return getObject(delegate);
    }

    /**
     * Translates from IModel of type T to object of type A
     *
     * @param delegate
     * @return adapter value of delegate model
     */
    protected abstract N getObject(IModel delegate);

    /** {@inheritDoc} */
    public void setObject(N object)
    {
        setObject(object, delegate);
    }

    /**
     * Translates from object of type A to IModel of type T
     *
     * @param object
     *            adapted object that needs to be unadopted
     * @param delegate
     *            delegate model whose value should be set to unadopted version of
     *            object
     */
    protected abstract void setObject(N object, IModel delegate);

    /** {@inheritDoc} */
    public void detach()
    {
        delegate.detach();
    }
}

it has

• Branching with Clones
• Branching with Bookmarks
• Branching with Named Branches
• Branching Anonymously

with a list of

• Advantages
• Disadvantages
• Comparison to git

each.

Doug Lea posted a note today on the concurrency-interest list that the bulk of the JDK 7 changes from JSR 166y (the second maintenance update) have been pushed in the latest JDK 7 M5 snapshots.

The fork-join library provides support for fine-grained parallel divide-and-conquer style parallelism. You can think of many of the classes adding in JDK 5 for queues, executors, etc as excellent building blocks for coarse-grained parallelism (on the level of a “task” or “transaction”). Fork-join works at a lower level, providing parallelism for working on a subset of a large data set in parallel.

so looking for alternatives i came across the recent announcement of HornetQ formerly known as jboss-messaging. even though i am not particularly known as a friend of jboss due to prior experiences with their AS, i chose to take that hornet for a flight. here´s what it turned out to be:

Arrival

download, done. as easy as that. well almost.

certainly you want to take a look at HornetQ-configuration.xml. there is binding to non-localhost and a few options like redelivery-delay, redistribution-delay and rates for consumer and producer to take care of.

if you´re on a linux env, you might want to use their AIO stuff, which is explained in great detail here.

Pre-Flight Preparation

as a happy maven user it took me a while to find out what libs i actually needed as a minimum to use HornetQ as JMS Implementation. just afterwards i discovered this nice blog article that gives it all.

basically it is:

   <!-- if you like that API better than JMS -->
   <dependency>
      <groupid>org.HornetQ</groupid>
      <artifactid>HornetQ-core-client</artifactid>
      <version>2.0.0.BETA5</version>
      <scope>compile</scope>
   </dependency>
 
   <!-- the actual JMS Impl -->
   <dependency>
      <groupid>org.HornetQ</groupid>
      <artifactid>HornetQ-jms-client</artifactid>
      <version>2.0.0.BETA5</version>
      <scope>compile</scope>
   </dependency>
 
   <!-- transport layer -->
   <dependency>
      <groupid>org.HornetQ</groupid>
      <artifactid>HornetQ-transports</artifactid>
      <version>2.0.0.BETA5</version>
      <scope>compile</scope>
   </dependency>
   <dependency>
      <groupid>org.jboss.netty</groupid>
      <artifactid>netty</artifactid>
      <version>3.1.0.GA</version>
   </dependency>

sidenote: i don´t get why HornetQ-transports for instance does not declare a dependency to netty. unfortunately with any jboss product, you have to dig for a particular foggy combination of jars that work together. (sorry for that obvious reference to hibernate )

Tower

there is none. ok, the HornetQ server exposes itself heavily via JMX, but you cannot expect anything similar to ActiveMQ in terms intuitive usability or comfort. on the other hand, using (and understanding) the JMX-exposed API gives you much more power than what the average JMS server provides.
what we (my company) did, was to create a simple webapp considerably equal to what the ActiveMQ admin-webapp is (without the screwing up part) to manage queues/topics, messages and monitor the nontrivial processes that JMS provides in terms of redelivery, dead-letters etc…

SCREENSHOT TO FOLLOW

there also is hermes, but we never got it running with HornetQ in a way that we could manage queues and move messages.

Choose Gangway

HornetQ is a JMS provider, yes. and even though i am not a fan of using a proprietary API over a standardized one, you might want to take a look at their direct API to messaging. it is a slightly different perspective (no difference between queue and topic) to JMS, but it is a little simpler in some corners.

we can afford going that way, because we have an abstraction on top of that, that protects our application code from a dependeny on a particular API, anyway.

Lift-off

first of all, you can easily embed HornetQ server into any app. beside tests, the usecase we had for that was the admin application mentioned above. this is not too important, but very handy as you can easily bundle these things together.
using the client API, as well as the JMS API is as trivial as you would expect. the only thing you might want to know is their way of implementing streaming of big messages.

Heavy Lifting

some people say, that sending big messages over JMS is terribly wrong from a conceptual perspective. well, it depends. we do have some usecases, where a message contains a job that really carries quite some data. i wont enter the discussion, if this job should better be persisted and just being triggerd by a small JMS message, but one thing is for sure: it is much easier this way.
so what am i talking about when i say “quite some data”? significantly less than 5mb. while this is not considered “big” in any other context, an ActiveMQ faild us with OOMs when recieving such a message even though he had 512m of heap.

any possible replacement for ActiveMQ for us had to demonstrate a reliable operation with messages that go up to 30mb.

HornetQ delivered quite good here. be it the JMS API or their own (supposed to be simpler) API to messaging, you can easily stream data into messages. the server then streams those messages into a large-messgae directory and the cake is eaten. this is not particularly reocket science, but our bad experience with ActiveMQ makes me emphasize this:
HornetQ copes with messages of any reasonable size!

in fact, we chose to use this pattern for any message we send (ignoring the performance resulting from the extra handling of this kind of message) in order to be safe and relax on mem requirements as much as possible.

Landing

we replaced some ActiveMQ servers in production environments by hornets and since then, we did not touch them. we set up (very frequent) nagios roundtrip tests and the like, and hornet did not let us down once.

even though i am not particularly known as a friend of jboss, i am grateful of this being not only open source but also isolated from jboss AS and the rest of their (sometimes bloated) ecosystem.

Final words

the advanced configuration is a little weird here and there and lacks documentation. it has a bunch of things, that do not provide value FOR US, like throttleing.
in operational tests, we discovered some weird (but reproduceable) behaviour when ungracefully stopping HornetQ. some messages were safe, but no longer moveable to another queue (brings NPE). we suspect this to be a beta issue that´ll be taken care of.

apart from that: HornetQ is easy to get started with, reliable, reasonably fast, highly configurable and (once you got the API) flexibly managable.

it instantly is a major player in OSS JMS provider market and, if you happen to have requirements similar to ours, a very good choice.

See Vassil Dichev´s Embedded Scala Interpreter

once more, they repackage an apache project to charge for it.

The WebSphere Application Server JPA implementation is based on Apache OpenJPA, a leading open source Java persistence framework. This alpha provides the Apache OpenJPA 2.0 implementation with IBM enhancements to benefit integration with WebSphere Application Server. The Apache OpenJPA 2.0 implementation includes improvements and benefits over previous releases and even beyond the JPA 2.0 specification.

Well, I just wanted to speak about an issue for which I didn’t find any proper answer yet.

The matter is gui testing. Currently, at work, we do proper unit test for “framework level code”. By “framework code”, I mean code being in some utilities or services projects which are put there to be reused. These tests are usually fairly easy to do, since the context is well known. Furthermore, as once as we change this code, these tests prove their value. As changes are made quite often, be it only when adding new stuff and thus refactoring, we feel like these tests are good bang for bucks.

For example, recently, we saw a bug in some on “framework code”. We wrote a failing test for it (well, I’m not 100% sure of that, but we should have had anyway ), fixed it and, on the go, spotted some possible improvements. We did them as well, then ran again all tests and we were pretty confident about it.

But, then, what about “project specific code” ?

Hum, what’s in it anyway ? Some “framework level code”, for sure, which is already tested, and then some JPA, wicket and business related code. Testing the JPA code would basically mean testing the JPA layer, which is pointless. What about the GUI then ? Well, wicket isn’t exactly the easiest framework for it… The way its generates the ids make it hard(er) for most of the html test tools, like for example selenium. And even if, what to test actually ? Should we do some “clicks through” tests for all use cases ? All possible navigation paths ? And what about the data needed by these tests ? Using WicketTester, then we would be at pain with jquery heavy pages (well, I guess most of the selenium like frameworks are at pain in this case…). Overall, the efforts to put there are likely to be important.

So, what about the gain ? The odds that we’ll touch again these classes are quite low, way lower than framework level code. Basically, we don’t reuse these stuff. And if some functionalities/pages are fine enough, then we may even not touch them again before very long.

In the end, we have some layers which are, at the same time, harder to test and with less “return on investment”. It looks like not testing these “project specific/gui layers” is a good idea…

However, which bugs the end users, tester or product owner are likely to see the first ? The gui bugs, for sure. Worse, whereas framework layer code tends to be mostly Java, the front end relies heavily on nice stuff like CSS, html and javascript. And as if refactoring wasn’t already hard enough there, Wicket, with its string based property and compound models, makes it even harder. So in the end, this gui layer is quite error prone and highly visible to the “customers/users”… Bad isn’t it ? And don’t forget all these quirks about back button, interruption of page loading, browsers inconsistencies and many ui possibilities… Even worse !

That’s where my issue with ui test lies… This ui layer is a pain to test, and would be tested mainly for just a development, without much reuse. But, it’s an error prone layer. And it’s the most visible one… So, if, like me, you’re kind of fond of tests and bullet proof code, then you might well share my dilemma…

What to do then ? Well, for the time, I’ve no proper answer. I guess I should try to spend more time testing my ui before giving it to the outer world, even it feels awkward to do it manually. For sure, exploratory tests might help, but again they’re manual and in no way comprehensive… No clear solution here for me, unfortunately…

Any hint deeply welcome ! In fact, I guess that’s the (hidden) aim of this post : maybe someone’ll come with some magic bullet(s). After all, Christmas is coming soon, so it’s dreaming time anyway

++