"Invalid Cast (check your mapping for property type mismatches); setter of classname"

Right besides the sign stands NHibernate, its expression unreadable. Our hero, unsure of which path to take, asks for directions as to what to fix.

NHibernate: “The problem lies…” – sweeps hand widely at the class – “that way”
Ricardo: “Where? Which way?”
NHibernate: “In a property…”
Ricardo: “Of course, all it has are properties! Which one?”
NHibernate: “No… I’m afraid I’ve said too much”

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.


=== Entering application hipe
/opt/local/var/macports/build/_opt_local_var_macports_sources_rsync.macports.org_release_ports_lang_erlang/work/erlang-R12B-2/bin/i386-apple-darwin9.3.0/hipe_mkliterals -e > hipe_literals.hrl

erlc -W +debug_info +warn_obsolete_guard +inline -o../ebin hipe_rtl_arch.erl
make[3]: *** [../ebin/hipe_rtl_arch.beam] Bus error
make[2]: *** [opt] Error 2
make[1]: *** [opt] Error 2
make: *** [secondary_bootstrap_build] Error 2


Still haven’t found a fix, but thought about sending this out as Googlebait just in case.

Update: there is now a bug report at Macports.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Brilliant.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Coming from subversion and cvs, something struck me as odd: if you do git commit, it will only commit the changes that you have just added or removed – anything else needs to be explicitly added to the working index, even if you have added it before. Bit of a pain if you simply want to commit everything.

Digging around the git docs, there’s an option you can pass so that it will just commit all files you have previously told it about: git commit -a. There’s also an option invoked by git commit –interactive that causes it to ask you for each file if you want it to go on the current commit or not.

As to why that is:

What git add does is to move the current version of the named file to a special staging area, holding files that are ready to be committed. And what git commit (without other arguments) will do is to take the index and make a new revision out of what the index contains. git commit -a is just a convenience which adds all modified files to the index, and then commits the result.

How does this affect you? The first thing to remember is this one: only run git add on new files just before committing. Otherwise, you’ll commit the wrong contents of the file.

It takes a bit getting used to, but it’s a lovely tool so far. If you’re thinking about using it yourself, start by reading Git Magic, and then after the first three chapters move to Using git without feeling stupid and its part 2.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Write a ring benchmark. Create N processes in a ring. Send a message round the ring M times so that a total of N * M messages get sent. Time how long this takes for different values of N and M.

Here is my solution:

-module(ringproblem).
-export([start/2, ring/1, rpc/2, benchmark/3]).

% Spawns a function and registers it as an atom.
start(AnAtom, Fun) ->
    Pid = spawn(Fun),
    register(AnAtom, Pid).

%% This loop receives a parameter that's either the next Pid on the chain,
%% or null if this is the last process on the chain.  It then passes the
%% message to the next process. Once the cycle has been completed, it
%% calls back the original caller to let it know.
loop(F) ->
    receive
	{ From, 0, Counter, Message } ->
	    F ! die, % tell the next process to die
	    From ! { ended, Counter },
	    io:format("Cycle for ~p ended.~n", [Message]);
	{ From, Number, Counter, Message } ->
	    case F of
		void ->
		    firstProcess ! { From, Number - 1, Counter + 1, Message };
		_Other ->
		    F ! { From, Number, Counter + 1, Message }
	    end,
	    loop(F);
	die ->
	    case F of
		void ->
		    io:format("Last process died");
		_Other ->
		    F ! die,
		    void
	    end;
	Other ->
	    io:format("I don't know what to do with ~p.~n",[Other]),
	    loop(F)
    end.

%% Sets up a ring of at least 2 elements by recursively building it back
ring(Elements) when Elements >= 2 ->
    Pid = spawn(fun() -> loop(void) end),
    ring(Elements - 1, Pid).

%% If we have no more elements, this is the first process. Register it.
ring(0, Pid) ->
   register(firstProcess, Pid);
%% otherwise walk back
ring(N, Pid) ->
    PrevPid = spawn(fun() -> loop(Pid) end),
    ring(N-1, PrevPid).

%% Do a RPC call to the first process, which should have been registered, and
%% wait until we receive a message telling us that the cycle is done.
rpc(Times, Request) ->
    statistics(runtime),
    statistics(wall_clock),
    firstProcess ! { self(), Times, 0, Request },
    receive
	{ ended, Counter } ->
	    {_, Time1} = statistics(runtime),
	    {_, Time2} = statistics(wall_clock),
	    U1 = Time1 * 1000,
	    U2 = Time2 * 1000,
	    io:format("Ring time for ~p calls = ~p (~p) microseconds~n",  [Counter, U1, U2])
    end.

benchmark(Elements, Times, Request) ->
    ring(Elements),
    rpc(Times, Request).

You would run it like this:


Eshell V5.6.2 (abort with ^G)
1> c(ringproblem).
{ok,ringproblem}
2> ringproblem:benchmark(1000, 3000, "Round and Round").
Cycle for "Round and Round" ended.
Ring time for 3000000 calls = 8360000 (8416000) microseconds
ok
3>


And eventually, possibly a couple seconds later, you’ll get a notification that the last process has died.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

After downgrading to (the also free) VMware server 1.0.4, the virtual servers have been working like a swiss watch for a couple weeks.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

• Image loading
• Image saving
• Cropping
• Masking
• Scaling

The latest version of the documentation will remain at the Grails wiki. You probably should also read my post on JAI and masking operations if you intend to use it to mask images.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

After much hair-pulling, I’ve figured out a workaround: while debugging only stops on a breakpoint the first time while using the integrated Eclipse browser, it does work when configured to use Firefox as an external browser (Camino gave me an error on launch). To change that option, go to Window | Web browser and select something different from Internal Web Browser.

Hope it helps those out there still looking for a solution.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

For those wondering what it is, Grails is a framework for the Java platform designed for high productivity. I started using it for a project with version 0.5, have since moved to 0.5.6, and will soon upgrade to this latest version.

While I appreciate Ruby on Rails’ ideas, I don’t like Ruby itself as a language. We also know several clients that have Java as their standard platform, so Ruby on Rails or even Plone-based projects were out of the question. Groovy on Grails also caught my eye because, underneath, it’s all Java – so we had the wealth of Java libraries available to draw from.

Development is a breeze, and whenever I’ve encountered something that wasn’t well explained in the documentation the Grails community has been extremely helpful.

We’ve had no stability issues or performance issues, even though it’s months away from a 1.0 release and we’re testing it on a server with limited specs. The speed is beyond what I expected: pages that take a second or so on development on my Core2Duo 2.33GHz are spit out in milliseconds on the live site, which is running on one of Zone.net’s lower-end VU200 virtual servers.

Productivity has been great, even considering the learning curve. I came to Grails with no knowledge of Spring or Hibernate, and have had on occasion to learn not only of Grails and Groovy but the foundation it’s based on. Even so, in most cases it’s been out of curiosity for how something is being done behind the scenes (much time spent scrying Hibernate logs or looking at the generated db structure).

For me, the best thing so far was realizing that for the first time in a while it was taking me longer to come up with an implementation or design that I felt happy with than to actually execute it, and to experience how easy it is to change courses if I come up with something better. No “crap, if we do it better we’ve got to throw away three day’s worth of code” resistance.

That means my time is being used where it’s truly useful, and I’m ending up with approaches I’m happy with.

I’m absolutely sold.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

When you work in an environment with experts things simply work. They are easier to use and require less initial training. The software is easier to modify. Requested changes happen more frequently and easily. Things just flow. It is the difference between Apple and Microsoft.

One of the comments hits squarely on the reason why things are not likely to get any better, if companies keep playing the same game:

If you do 10x better work, you get 10% better pay. If you’re a hotshot, it is simply not economical to go into industry. You do a startup, contract work, or switch fields (entrepreneurship, i-banking, etc.).

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Things were working swimmingly, but when I started testing with images from my phone’s camera the following exception started appearing:

Error: One factory fails for the operation “jpeg”
Occurs in: javax.media.jai.ThreadSafeOperationRegistry
java.lang.reflect.InvocationTargetException

[...]

The problem was not how the image had been created, as I originally suspected, but actually the image size – this seems to be a rather obscure way of telling you I’m out of heap space!. Increase the heap space or try with smaller images, and it should work just fine.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

My first candidate was Apache Derby, based on some good performance reports I’ve read. Unfortunately, I immediately ran into a problem, where objects weren’t being committed right away. I would execute something like:


new Animal(name:"Misingo").save()
def misingo = Animal.findByName("Misingo")


And while the save call would succeed, the findByName function would fail. I began digging through Google trying to find a work around, but the voice of reason in my head told me that if I was having to look for fixes for trivial tasks, I shouldn’t rely on it for anything major.

Dropping back to considering HSQL with file-based tables, I started researching HSQL performance and ran into a HSQL vs Derby, where a history of Derby bugs is mentioned and several benchmarks are pointed to. This same article brought the very promising H2 Database to my attention, which comes with some pretty impressive benchmarks.

I downloaded it and attempted to get H2 working with Grails 0.5.6, and got an easy enough to fix error:

Could not determine Hibernate dialect for database name [H2]

In order for it to be recognized, you’ll have to create a file hibernate/hibernate-dialects.properties containing the following string:


H2Dialect=H2


This got H2 running and working perfectly for my development tests, but it failed when attempting to use production:

could not get database metadata
org.h2.jdbc.JdbcSQLException: Table SYSTEM_SEQUENCES not found [42S02-55]

Google searching for “H2 SYSTEM_SEQUENCES” yielded only 3 pages, two of them in Japanese. Not promising. Some testing determined that if the data source’s dbCreate property is set to either create or create-drop everything went smoothly, but it failed when set to update.

I went back to the H2 site, and found the following on the FAQ:

Is it Reliable?

That is not easy to say. It is still a quite new product. A lot of tests have been written, and the code coverage of these tests is very high. Randomized stress tests are run regularly. But as this is a relatively new product, there are probably some problems that have not yet been found. Areas that are not 100% tested:

• Platforms other than Windows XP and the Sun JVM 1.4 and 1.5
• Data types BLOB, CLOB, VARCHAR_IGNORECASE, OTHER
• Cluster mode, 2-Phase Commit, Savepoints
• Server mode (well tested, but not as well as Embedded mode)
• Multi-Threading and using multiple connections
• Updatable result sets
• Referential integrity and check constraints, Triggers
• ALTER TABLE statements, Views, Linked Tables, Schema, UNION

[...]

Evidently H2 is not ready for prime time – at least for my purposes – but it was refreshing to see the developer be upfront about it. I’ll wait before using it in production, but my hat’s off to Mr. Thomas Mueller – the creator – for his work on creating his own DBMS from scratch (again, he was one of the original creators of the Hypersonic SQL Project, on which HSQLDB is based).

So where does this leave me? Back with HSQLDB. Its performance is good, it’s stable and provides everything I need. I guess I must be getting old if I’m deciding based on stability and ease, not on shininess, but sanity has prevailed.

And after all, I did give shiny new thing a fair shot.

Bonus content:

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

PS: Yes, I’m making the Assembla backups myself. I’m not too keen on giving someone else the secret access key.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

I started off from the code on this relatively old article, adapting it to my needs on Groovy. The intention was to:

1. Get an image
2. Crop it to a square
3. Generate a thumbnail
4. Add a mask to the thumbnail

The original test code we wrote work perfectly. The mask function was (with control output added):


public applyMask()
{
println("ON APPLY MASK")
println("Mask ${mask.getWidth()} x ${mask.getHeight()}")
println("Alpha ${alpha.getWidth()} x ${alpha.getHeight()}")
println("Image ${image.width} x ${image.height}")

println("Result ${result.width} x ${result.height}")
}


Thumbnails were generated with:


def d = new ImageUtils()
d.load("cropped.jpg")

And having generated them, we iterated through them with:


def e = new ImageUtils()

[178, 133, 69].each {
e.load("Thumb_${it}.jpg")
e.loadMask("Mask_${it}.jpg")
e.loadAlpha("Alpha_${it}.jpg")
e.applyMask()
println "Created Masked thumbnail"
e.writeResult("Masked_${it}.jpg", "JPEG")
}


to apply the corresponding masks.

Turns out that when the code was optimized to just handle everything in memory, without an intermediate save, the resulting image ended up missing a few pixels in all sizes. Executing


[178, 133, 69].each {
c.thumbnail(it)
println "Created thumbnail"
c.swapSource() // Assigns the result RenderedOp to copy to work from
c.loadMask("Mask_${it}.jpg")
c.loadAlpha("Alpha_${it}.jpg")
c.applyMask()
println "Created Masked thumbnail"
c.writeResult("Masked_${it}.jpg", "JPEG")
c.restoreOriginal()
}


gave us results like:

Mask 133 x 133
Alpha 133 x 133
Image 133 x 133
Result 133 x 128

This seems to be a JAI bug when working completely from memory RenderedOp sources. Saving a temporary thumbnail and loading it again before applying the mask works just fine.


[178, 133, 69].each {
c.thumbnail(it)
println "Created thumbnail"
c.writeResult("Thumb_${it}.jpg", "JPEG")
c.load("Thumb_${it}.jpg")
c.loadMask("Mask_${it}.jpg")
c.loadAlpha("Alpha_${it}.jpg")
c.applyMask()
}


No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.