Live architecture with Java, Spring, JPA and OSIV

This post is about an architecture where live (attached) JPA objects are used in the presentation layer. You can expect OSIV (Open Session In View) pattern mentioned, though I’ll focus more on ways how we made it work well enough for us – safely and without LIEs (LazyInitializationException). It is just my story with my experiences, no big discovery here.

I can’t tell if it is any official name, but we call it “Live architecture” because live JPA entities are available in the presentation layer. While we use it with Spring/Wicket mostly, it is the same with any other presentation framework – and probably applies to JavaEE without Spring too (if you use OSIV).

DTO vs Live architecture

In our company there are “DTO guys” and “live architecture guys”. We all know DTOs (Data Transfer Object) and how to work with them, more or less. Their rise to fame came with the need of coarse-grained calls to remote EJBs and they became prominent “pattern” then. Even with local calls people use them to strictly divide layers. I used them on some projects, then not on others and then again I used them with GWT/Seam applications (never liked the idea of JPA entities being preprocessed for me and dragged all the way to the GWT application).

Everytime I start talking about “live architecture” that drags entity objects into the view there are architects who just say “that is no architecture at all”. And I say “whatever…” I remember projects where we “broke” a clean architecture (e.g. “everything must go through this facade!”) and the result was less and cleaner code, easier to understand, better performance even. Was it universal? Hell no, it wouldn’t scale in most cases, but in that particular case scaling was not (and after all those years still is not) necessary.

My recent story with the live architecture is based on a project where it was settled that it will be used instead of DTOs. You have to translate DTOs somehow from business objects and back. You can generate it, you can automate it, use reflection – or do it manually. Any way always adds something that is not necessary for all cases. Our views were mostly based on JPA entities and it was just shame to translate them to DTOs for the sake of transformation itself. I’m not saying DTOs are bad – well we use them for more complicated views, mostly for lists showing joined tables. You can of course build a view and design an entity over it – and we do it too…

There is no fundamentalism in this – we use entities as much as we can. I strongly believe that in normal scope projects people often overdo it with “clean architecture” and don’t care about “clean code” as much. And I strongly believe that cleaner code itself matters much more than that cloud castle of architecture (without underestimating the architecture itself!). After all our projects are quite simple multi-tier applications with a bit of clustering. No grid, no hi-perf, no America. So we use entities, because they are placed under the presentation layer (good dependency direction) and they only carry data. And when this is not enough, we use DTOs too. Simple.

Business logic objects and dumb entities

You may have different rules for your live architecture (projects using OSIV) – and that is fine. Ours start with don’t use entities to anything else – no business logic, maybe some simple computed properties, that is alright. You may call this Anemic Domain Model – but I don’t care. Logic is in separated objects that use one or more entities. It is not exactly DCI, but it is not very far from this. For many other reasons (unrelated to the live architecture) I prefer having business logic objects that performs specific scenario – the best case is 1-to-1 mapping with a Use case from the analysis document.

Let’s talk about this picture for a while:

Presentation layer can be anything – component (Wicket) or controller (Web MVC) driven. It calls the service layer (typically a Spring bean or EJB) and this further uses that “cloud” with various business logic objects. Very often I prefer create/use/throw-away pattern. In constructor the object gets its context and then it does something – preferably in one method call, but it may be a sequence too, although this is more fragile approach. Important thing is that business object can store its state during the business logic execution – it is thread safe if it is created locally for one service call (that’s why I don’t use singletons here). Sometimes state is not necessary, but in more complex cases it is. And I like fields much more than dragging list of parameters between private methods.

This business logic uses DAOs (or @EntityManager directly) to work with the DB – and of course works with entities in the process. Because entities are dumb (DCI idea, but not only theirs) they are perfect DTOs (that are also dumb). Of course there are some concerns about entities used as DTOs and you can find many questions about this issue (and not only in the Java world). Entities are POJOs – in theory – but you may drag some proxy object up there into the presentation layer. There is a lot of magic in entities, you sometimes don’t know what they are (my class or some modified class already?) – but under the most circumstances you don’t have to care that much really.

Best practices

Now let’s talk about our best practices. Presentation layer code knows entities, but doesn’t know ORM! This is probably the most important thing. Of course the dependency on the JPA is implied somehow. Of course client programmer has to know the data model and has to know how to traverse the objects he wants to display. But he absolutely can’t use EntityManager. Our first “live architecture” project didn’t have clear separation of these roles and some LIEs were fixed like “you know, here in this page before you call the service… put evict on this object there”. I wasn’t there when this project started, so I just went like “what?!?!” And I forbade this for the next project I could affect.

Next rule is rather about the communication than the technical one – presentation programmer always has to know what he gets from the service call. Otherwise he risks that LIE again. But LIEs in presentation are easy. They are easy to fix in model, in service/business code or in the presentation code (that is the most of the cases). You always have to share some model between business logic and presentation (and developers!) – and we share the data model itself. If you don’t plan to change your layers this is perfectly acceptable. I’ve actually never saw any change of technology that would satisfy using different model introduced on the facade level. So why to do it if you ain’t gonna need it? (Of course, you may need it – and you are there to say as an architect.)

Getting data is easy (talking about live architecture problems only ). You may need separate methods for every view – especially if selects are not generic enough. We have “filter beans” with single superclass and we use these beans with a few service methods (getSingleResult, getList, etc.) that are rather generic in nature. DAO-like even. It works for us, filter beans are the common ground for client and server programmer to communicate and they are part of the service layer API. We can have common FilterBean interface, because we use our custom filter framework behind. But you can use filter beans without common ancestor and have many service methods to obtain data. This is probably even cleaner.

Transactions, saves, updates

Originally we used DAO-like save on service layer too. We also didn’t have clear strategies when objects are alive and when not when the presentation layer called the service layer. If you had in one HTTP request read and write call, then the entities were alive if the write used result of the read. If you had just an update, then they were not. “Objects may come alive or not, let’s not assume that they are alive,” was our first strategy, though I didn’t feel very well about “or” used in the sentence. Never use contradictions in your assumptions. With a big help of our tests we managed to clean this mess up.

Our tests were TestNG based, they were not unit tests but mostly we tested the service layer playing the role of the presentation layer. It was funny how often the test passed and the user test (using browser) failed, but also vice-versa! Sometimes the test didn’t prepare the same environment – and we started to realize, that the service layer must assume less and be more strict. The biggest problem was that the presentation layer could change an entity A that was read in the request (hence alive) and then call service saving an entity B. The service layer had no chance to know about the A being saved in the same transaction. This lead to one very simple idea – we always clear session before calling transactional service methods. I forgot to say that we use transactions on service layer, so you can have more transactions in one HTTP request/persistence session.

Stepping back for a bit – client programmer knows that when he calls a service, his objects are alive. He can call multiple reads – and he knows that all things are still alive and he can base the next read on an attribute that is loaded lazily. In our case there is only one write/transaction called in one HTTP request – and it’s mostly the last call as well. If I wanted to make our policies even more precise I could say “always clear the session – for every service call”. This would mean less comfort for the client programmer. Or you can go for “dead” entities instead of live ones (see Other possibilities further).

Now the business programmer knows that any object that enters transactional service is detached and he can choose what to do with it. Do you need just to save the changes? Merge it (or call JPQL update, or whatever). Do you need to compare it to its original state? Read the object by its id and do what you need. Do you want to traverse its attributes? Well, better reload it first to make it attached again. We enforce this by a custom aspect that is hooked on an existing Spring @Transactional annotation.

This assumption would be very useful for read/list method too. Now the developer never knows if he has to reload or not. But read methods are not so complex and reload of the parameter entity should never harm either. Also – read/list methods are not transactional, so whatever he does, he can’t mess up with the persisted data. So this is our compromise between the client programmer using live objects and the service layer being secured enough. There is much less LIEs in our back-end code (which are harder to catch than those on the presentation layer) – actually I didn’t see one for a long time – and there is no chance to tamper with the data accidentally.

As a side note: Many of our problems were also caused by our presentation architecture – we load data, display them, then forget the content to keep page/session small and we just remember the IDs of the objects. When edit action comes, we reload the object from the service by its ID, modify it and then call the transactional write service method. To make this more convenient we have our custom ReloadableModel class for our Wicket pages, so before the model (entity obect) is to be updated, it is always reloaded from the service too (this is not a big performance hit, it often goes from the 2nd level cache anyway). This may not be very lucky solution but it was one of those we had to stick with for the time. You may or may not run into these kinds of problems. In any case, making your contracts and policies more strict and clean is always a good thing.

Other possibilities

There is not only Live vs DTO option. You can also use entities, yet always closing the session when the service call ends. This gives you the same model, less easy presentation changes, but it definitely is cleaner from the service layer point of view. You can make more strict contracts, performance is all down there and not ruined by lazy loads on the presentation layer, etc. I know this, we use this for other projects too. But I also know that people use OSIV a lot and that is why I wanted to wrap-up our experiences with it. You can come up with other policies too – for instance one read or write per request and nothing more. Do it all in one proper service call, don’t call many selects for every single combo-box model for instance. I agree with these approaches actually. But sometimes we don’t have the luxury of choice.

In any case, try to do your best to clean up the contracts as much as possible, avoid contradictory ORs in your assumptions and – I didn’t focus on this point much in this post – test your service/business layer. Contract and policy is one thing, but you have to ensure them – force them, otherwise they are not contracts, just promises. Because that is your safety net not only from the architectural standpoint, but also from the functional one. But that is a completely different story.

Dorling Kindersley vs IKAR preklad

V poslednom čase som si obľúbil knihy od Doling Kindersley – najmä ich encyklopédia (Earth, Ocean, Science) alebo aj ich detské verzie (Animals alebo Nová encyklopédia pre deti). Keď môžem, uprednostním originál – ale práve posledne dve menované (detské) máme v oboch jazykoch a Vesmír máme len od IKARu – tú dokonca najdlhšie, ešte vo väčšom formáte ako ich po novom tlačí DK.

Kniha super, zaujímavá, pútavá, dobrý výber materiálu, fotiek, všetko v najlepšom poriadku – až na chybičky pri preklade – a to hneď zo začiatku knihy, kde sa pri trošku pozornejšom čítaní nedali obísť. Hovorím o čítaní, nie o hľadaní chýb. Prvá veta, ktorá zrejme bola obeťou trošku náročnejšej angličtiny znela… no však tu je fotka:

V originále je uvedené (výrez z Amazon náhľadu):

Keby som nevedel kontext, možno aj ja by som to takto preložil, lebo ide o neľahkú a nie celkom jasnú konštrukciu vety. Predpokladám však, že hviezdy neobsahujú tmavú hmotu, a hoci vznikli z prachu a plynu, nehovoril by som že obsahujú oblaky plynu. Skôr išlo o to, že “okrem hviezd galaxie obsahujú aj…” Či pôvodná veta naozaj znamená “Tak ako (obsahujú) hviezdy, tak galaxie obsahujú aj oblaky plynu…” Určite by som ale zmenil slovosled a spravil to jasnejšie.

Druhý kiks bol pomerne triviálny – copy/paste chyba (pre tie mám ako programátor pochopenie ). Predsa len sa mi nezdalo, že by Merkúr bol od Slnka ďalej ako Zem:

Poďme sa ešte pozrieť na problém s červienkou (Robinom, tak sa volá aj môj syn) v encyklopédii zvierat pre deti:

V nejednej knihe alebo rozprávke (toto bolo tuším DVD s psíkom Spotom, po anglicky) sa nachádza vtáčik Robin (červienka). Keď už sme nedávno kúpili tú encyklopédiu, tak som do nej nazrel a ukázal Robinovi Robina (nemusím snáď objasňovať, že som synovi ukazoval vtáka ). Manželka siahla po preklade, aby sme sa ubezpečili, že ide o červienku – a tam na naše prekvapenie bol drozd sťahovavý:

Na počudovanie na inej strane bola červienka v poriadku:

Neskôr som zistil, že drozd sťahovavý je tzv. “American Robin”, každopádne latinské meno je iné. Červienka je drozdovitý vták, aj americká verzia je pre laika podobná, ale prečo nepoužívajú pri preklade ponúkajúce sa latinské meno, to neviem pochopiť.

Na tej istej strane ako zlý drozd bol aj iný rozkošný preklep (slovo je zväčšené v editore, typografia bola v poriadku):

Proste – keď sa darí, tak sa darí. To sme dnes tie knihy otvorili poriadne prvýkrát. Pre nás to znamená jediné – udržať si kritický pohľad na to, čo čítame – najmä v preklade. Samozrejme ani originál nie je zárukou dokonalosti, ale dobre viem, prečo uprednostňujem nepreloženú knihu pred prekladom. Duplom do nášho jazyka s pomerne malým trhom, kde sa zjavne poriadna korektúra či redaktor (či kto to má na starosti) asi nezaplatí len tak.

Stargate, DS9 and other Heroes

I once compared Prison Break with Shawshank Redemption and I wanted to talk about other typical TV shows from the last 20 years or so, where it all goes and what I miss so much about the recent shows. Just to go quickly through what I liked and what not. I liked Star Trek Deep Space 9 – this is one of those long term relationships – and very similar it is with Star Trek: SG1 and Atlantis. I liked 24 (wrote about it here…). I liked Dexter though I stopped after second season and I simply don’t want to go on to the fourth season to see her dead (ok, I saw that scene, obviously ) – but Dexter was really refreshing. I liked first season of Tudors (but I’m not much interested in the next parts) and I really liked fantastic Game Of Thrones – though they really should not let “Boromir” die. So, sci-fi, fantasy, semi-historic, action – I like it all, though sci-fi is probably my favourite.

What I liked less was Battlestar Galactica – how I like it in overall, I just can’t stand those shifts in characters. You just don’t know what to believe. When T’ealc becomes enemy of the rest of guys from SG1, you just know that he is sick or something. You know your heroes. But BSG? You just never know what to believe. And I don’t think that Stargate show doesn’t have interesting twists here and there. But not so crazy like BSG. Or, when I wrote word heroes – I remembered my probably biggest let-down. I watched two season of Heroes. Concept, visuals, idea – all great. But so much of stupidity, so many cliches with the bad guy always running away. And then time-shifting with good heroes becoming bed. All those wannabe surprises and forced shocks – after that an episode from Stargate or DS9 just caresses me so nicely!

I don’t know what is wrong with some of these new shows. Are we running out of ideas? Do we need to push the limits further no matter what? Probably yes. A have to admit that I was able to watch BSG all the way through and I was generally satisfied in the end. I also watched Razor and The Plan – and it was nice to go the whole way. I never forget Galactica going down the atmosphere on New Caprica or Pegasus down taking few cylon star bases with it. Those were magnificent scenes and for those I can forgive the big of mystery that somehow wasn’t believable for me (especially around the final five).

Once I tried Buffy the Vampire Slayer – and while it was fun it somehow didn’t grow on me (though I definitely liked Buffy ). Lately I read xkcd.com regularly (from the old ones to the newer) and there are many hints on Firefly show. Because it wasn’t the first time I’ve heard about it, I decided to check it – and with 14 episodes total + one movie (Serenity) it was quite a brief encounter. And I was more than satisfied! Not only there was that lovely doctor from Atlantis and beautiful cold Adria from SG1 (both of it shot after the Firefly actually) the whole stuff was well thought out, mix of sci-fi and western was very catchy, but without cliches, scripts are indeed great and final movie was just overwhelming. If you don’t know what Buffy and Firefly have in common – Joss Whedon is the man – and that’s why they are in this single paragraph. (Watching the Firefly was also good thing for some further xkcd reading. )

After Firefly (not that my life is divided to B.F. and A.F.) I somehow got more and more suspicious that “classic” series are the matter of past. Now it’s important to compete with BSG, Heroes and Prison Break. Well… whatever people want. New music is still good (among tons of cheap stuff) and so will be TV shows I guess. I can still see the chance there – Game Of Thrones for instance, although it’s not something that would “caress” me like Stargate. Or The Firefly. Or the fond humour in DS9.

Of course your mileage may vary – but I bet there are other people out there that must have very similar feeling. And don’t simplify it just to “you’re getting old!”

Three years with Java Simon (4)

Today I’d like to cover the rest of my Java Simon story. In the previous posts we talked hardly about the start, but the rest was actually quite quick. With Callbacks, JMX support, JDBC proxy driver and much better design we were ready to release our 2.0 version.

June 23, 2009, Java Simon 2.0, monitoring API, released

There was one major problem with this version – we needed 2 different JDKs to build it. JDBC 3 would not compile against JDK 1.6 because Java 6 required higher version of it – which we didn’t want, so we could use it on application servers without support of newer JDBC. JMX 1.2 shipped with Java 5 – on the other hand – didn’t support features we needed, mostly around MX Beans, returning more types of objects and so on. So JMX was compiled with Java 6. You can imagine the problems we had when we started using Maven as a build (though Maven still is not exclusive build tool for us).

Well… Maven. While I like the idea of it – especially dependency management is truly great – as a build tool it is incredibly in the way unless you read tons of the stuff. Originally I hosted Java Simon on java.net repository, but then Oracle somehow made it more complicated (and malfunction altogether for a while if I recall correctly) and I decided to switch to Maven Central. That was right decision of course, but the pain behind it was just crazy. Unless you have the process mastered it takes a lot of pain to deploy your first software there. However – our clients wanted Maven repo – and I did my best to provide. I learned a lot in the process, but no one will convince me that Maven can’t be MUCH simpler. And deployment on Maven Central is just horribly bureaucratic compared to FTP upload. Guys at Sonatype do their best in support though, they probably have to answer tons of stupid questions (at least for them). After all I complained more about it previously, so let’s just skip the rest with saying that 2.5.0 version was the first on Maven Central – and someone else had to deploy it for me. 3.0.0 was delayed a lot – Maven being 95% of the reason. Now I can release (at least from that computer where release plugin doesn’t throw infamous out of bounds exception without providing reason…) and it is a tremendous relief.

Talking about 3.0.0 – release announcement was here:

Java Simon alive and kicking with 3.0.0 available

As you can read in it the biggest theme was aligning of the Java dependency – now we can build it with JDK 6 only. Aside from that it was rather just a wrap-up of all the changes in 2.x line with some bug fixes reported for 2.5. Talking about bugs and issues – this was maybe the reason why I kept working on Java Simon and eventually made all the changes that slowly but surely shape the library. And this would not be possible without users – and especially active users. Reports were coming more in bursts, often from one reporter for some time. One thing I can say with my head straight up – I was always very prompt to answer and fix where appropriate (mostly they were indeed bugs).

To talk to our users we created Java Simon Google Group shortly after version 1, but this was mostly an announcement tool. Here and there someone new asked the question though – and again, I answered as soon as possible. Luckily, Java Simon is low-profile library, so the traffic was rather negligible. To sum it up – users who had problems were my motor in the end. The main problem probably was that later we had no project to use with Java Simon. There seems to be some chance now at my current job, so I expect more enhancements.

Here and there I still change some method names (some changed in 3.1, next changes will appear in 3.2) – not that I like doing that but I rather name it properly later than never (oh, how I hate broken promises of original Java’s @deprecated!), but otherwise the core seems to be pretty stable for now. But there is still some room for improvements – especially new features:

1. delivering more useful tools like JDBC proxy driver – that one I particularly like for its simplicity, just add “simon:” in the JDBC URL and have it on the classpath – right now monitoring part comes to my mind, charts, logging, dumps to some history DB, etc.;
2. providing some neat Callbacks (many things from the point 1 are actually implemented thanks to these);
3. web console where you can easily read your Simons.

Actually – there should be web console available in our next release (3.2.0) – we acquired new committer from among our users. That’s the true open source community story. You can’t even imagine how happy I was about it.

Of course – my life is not only about Java Simon. I have a family, regular job where they’d hardly pay me for Java Simon alone, I like doing music (soon more about it too) and then I just don’t care about Simon for a few weeks, sometimes even months. Though right now I’m just taking a short break before we wrap up that 3.2.0 version – and you’ll hear about it.

Personal Log (4): Games I played in 2011

Last time I wrote “Personal Log” it was the end of 2009 and I wrapped it up in my post from more perspectives. Year 2011 was a good one (again), I started in a new job in January, our daughter Barbora was born in January – but even with these obligations (job and family) and a lot of additional work on Java Simon I still managed to play games. And to my surprise – quite a lot. I’ll talk only about single-player games because I can’t engage into any serious multi-player with all the children around.

So let’s start with the previous Christmas sales on Steam. I bought Mass Effect 2, King Arthur Pack, Railworks (now updated to Train Simulator 2012), Dragon Age: Origins, Crysis Complete, The Ball and Burnout Paradise. I even new I may not play some of them, but for the gamer it would be a sin not buy it when it’s so cheap. I want to play The Ball just because it’s made by Hourences and the team of other great mappers/modders who had been around Unreal engine and Unreal Tournament quite some time – and the game is original too.

In the last few years Mass Effect may be my favourite franchise – it’s a great shooter and I even forgot it’s RPG. Not that I have anything against RPGs – on the contrary – lately I played more RPGs of various types to my own surprise. I stopped playing other games and first I had to go through Mass Effect 2 (twice, different gender, different specialization). While you don’t exactly save the galaxy in front of the whole council (dead or alive ) like in the first part, the continuation is probably more epic on the whole. Not that I didn’t have any gripes about the game, I can’t remember them now – but I can remember how great the game was. As I remember the VI announcing another customer in line from the first part I still have vivid memories of quite a lot of scenes from ME2. This game flows well and it’s getting bigger and bigger towards the end. If you like sci-fi RPGs (or even shooters and can survive a few dialogues) then this is an absolute must-have. ME1 was great, ME2 is greater, with less annoyances, more variability in scenery, more subplots and one really nasty boss at the end. Fun factor 5/5, frustration 0, length just right.

King Arthur was the game I spent the start of the year with (after ME2 that is). I was really surprised with the blend of the Heroes M&M turn-based strategy (on a map that reminded me good old Defender of the Crown) and RTS battles – this all spiced up by simple text-based quests and some economy. I was really surprised how playable the game was. In the middle of it I thought I will loose because opponents’ knights (heroes) started to be very strong while I underestimated the power of some spells, but somehow I managed to outmaneuver them in the end. If you like strategies, try it. On the RTS battlefield it’s often about you knowing how to play around key areas and you may destroy a few armies with a single one. Maybe hard-core players would object, but I – casual nearly-ex-gamer – appreciated this concept. Fun factor 4/5, frustration 0, length quite long as expected. Typical “just one more move and I’ll go to bed” game.

Batman: Arkham Asylum is a bit difficult story. I had troubles to save single player games originally – I even wanted to play cracked version because of the stupid Windows Live service. But I figured out the offline profile feature (hidden in an unbelievably stupid way) and then I started to play. Another serious issue – no way to change controls. I’m ESDF guy, I touch-type too. WASD drives me crazy and when I want to press 1, I always press ` (key to the left) – well… because I touch-type! Not to mention that one disabled guy told me how missing controls customization can render the game unplayable for them. But back to the game itself. The story, visuals and all was quite reminiscent of Bioshock (both Unreal 3 engine games, by the way). I liked special tactics Batman can use, detective mode, gargoyles, visuals – this all was very good. You were really in the middle of Batman’s story with may heroes I didn’t even know. Boss fights were interesting, each of them a bit different. If you had any problem, game gave you some hints – I liked this as I’m less and less hard-core player and more and more a casual one. However here and there you played with different camera than over-the-shoulder and it made controls even more difficult (some boss fights mostly). You could take it as a minigame though. For one reason or the other I wasn’t so sucked into this game in the end, but I finished it after a few breaks (a few months mostly). Fun factor 4/5, frustration 3 (Windows Life + controls + camera), length just fine for me (progress meter counts also riddles, so you may probably end around 60% if you don’t care for the riddles). Recommended? Why not, but I don’t plan playing Arkham City.

In the middle of the year I suddenly got a strong need to play Half-Life 2 again – with both Episodes too, of course. As scripted this FPS is, it is simply great. Even the second run. I realized how many scenes in this game are simply so great. The river, first gravity-gun practice, “We don’t go to Ravenholm”, blocked bridge, Nova Prospect fight while waiting for Alyx, all those striders, Overwatch Nexus, Citadel… all of it! And then the Episodes – reactor hot-fix, run away to the station, fleeing the city, jumping over a broken bridge, Alyx down and up again, ambush in a homestead and amazing finale of the second episode. Without making any choices, without any active dialogues, the story is just great and I think I’ll probably have to go through it some other time again. Not to mention that it has great commentaries too – these just underline how well-thought this game is. Fun factor 5, frustration 0, length just fine – I even consider the main game quite long for a shooter, but I bet it’s short for others.

I was nicely surprised by Anomaly Warzone Earth. Simple, arcadish, and as goes with turret defense – very addictive. The concept of playing against the turret defense is smart, it is spiced up with a lot of specific details on particular maps and while this game was shorter in overall, it was also cheaper as it is no AAA title. Still the production was surprisingly good and the whole game is just smooth. Worth a few bucks for killing a few evenings, really. Fun 5, frustration 0, length could be longer, but OK.

Frozen Synapse on the other hand was too much for me. You have to dedicate more time to this game, it’s not good for a casual player I’d say. I expected some kind of Laser Squad I remember from ZX Spectrum (or the horrible port on PC) – but then – I had much more time (and much less games) back then. However the concept is interesting but without going for a multiplayer it’s probably not worth it. Fun factor 3 (single player), frustration 0, length – no idea.

And then there’s The Elder Scrolls IV: Oblivion. I played Morrowind before, but after some time I just gave up. Maybe I chose more boring class, but I guess different class wouldn’t change my mind. Oblivion is more or less like Morrowind – but more fun. Both these games are BIG. A lot of locations, a lot of characters, a lot of quest. However I lost my goal after some time. Oblivion is far better from this perspective than Morrowind, not only because it’s newer. But still – after shutting a few Oblivion gates I started to loose my focus, I didn’t know where to go and what to achieve in this game. This game is very good and having less other games and more time I’d probably play it (and maybe I’ll return to it). System is better than in Morrowind, a bit simpler, leveling goes more naturally, movement around the world map is faster – this all makes the game great. But when I compare it with games like Witcher and Dragon Age Origins (which I’m playing now though I hardly started the story) it’s easy to get lost here. I like RPGs that lead the player a bit (or more) – Witcher, Dragon Age, Mass Effect – these are much better in this aspect. For Oblivion the fun factor is 4, frustration 0, length was too much for me.

However, there is one easy way how to try a lot of games for little money. Wait a year or two and buy it during holidays sales if you’re not sure if you really want it. I remember buying Unreal Tournament 3 in metal case for quite a lot of money for my taste – and I was utterly disappointed by the game (though I loved UT99/2004). That’s why I hate to give anything more than 30 for a game I’m not sure of. Having Dragon Age 1 with all of the DLCs (another reason why to wait a bit) for 20 is much better deal then. I rather spend a lot of money on a lot of games risking I’ll not play a few of them than spending even more money on a few ones, half of them probably more or less disappointing.

And what were your favourite games in 2011? Let me know, anonymous comments are allowed as well – as always.