Because I have installed Cygwin as well and had it as a default shell for Console2, I decided to add a new tab configuration like this:

Main menu: Edit-Settings-Tabs-Add and then fill up things accordingly

Now the Total Commander part. While I googled a lot how to assign my custom command to a shortcut (hotkey) maybe I used different keywords, maybe I was just unlucky… I wrote to support in the end. Answer goes as this (thanks to Christian Ghisler):

1. Go to menu Configuration – Options (you can get here with Alt-O twice) – Misc (last option in the list on the left)

2. Choose your hotkey, I went for Ctrl+B (it doesn’t make any file “bold” I hope)

3. Click on the small magnifying glass

4. Click on usercmd.ini (all the way down)

5. Click on New

6. Choose a name, e.g. em_git_bash_here

7. Click OK

8. Enter the details (see lower)

9. Click OK in all open dialogs

Here is screenshot of the settings in Total Commander:

Here the -t obviously chooses the tab you want to open and -d sets the initial working directory.

BTW: The last dialog is the same like for a custom button. I actually found a blog about how to add a custom button with Git Bash Here, but assigning it to a hotkey was another story. Also running it in Console2 was easier than it seemed from various internet resources. Many advices pointed to the Windows Registry – but I didn’t want that.

Total Commander itself is a bit tricky. Don’t get me wrong, I love it and that’s why I have bought it (way too late, but I have) and also could appreciate support (right to the point). But when you want to find that %P is “current directory” you better google it. Ctrl+F in the Help window (very good one actually) does not help, because “source path” does not contain neither “current” nor “directory” obviously. With Internet at hand these are no problems at all.

BTW2: If you have your command in Total Commander named you can just reference it when you need it for button bar – don’t click on magnifying glass icon, just set Command value to “em_git_bash_here” (or however you named it) and you’re done.

Hope you made it with my procedure and my pictures. May the power of keyboard shortcuts (or hotkeys, whatever ) be with you!

S neodolateľnou ponukou E.Zľava od svojho seriózneho dodávateľa ZSE (člen skupiny e-on) som sa prvýkrát stretol, keď nám ju poslali poštou. Keďže v nej išlo aj o nejaké asistenčné služby a navyše viazanosť, nebol som si istý, či ju chcem – takže som ju jednoducho neriešil.

Lenže potom som raz dostal návštevu, ktorá mi to všetko vysvetlila. Asistenčné služby sme nechceli, ale zľavu za viazanosť… povedal som si, keď už je chlapík tu, prečo nie. Veci mi boli vysvetlené, ale z mojej strany išlo aj o istú mieru dôvery, keďže som jednal so spoločnosťou, ktorej zákazník som už nejaký čas, bla, bla, bla.

Chlapík odišiel, ja som vyrazil na web – a ľaľa ho, aj takéto články som našiel:

• Verní zákazníci zľavu od energetikov nedostali

• Na elektrinu zlákali aj nulovou zľavou

Tak som sa podujal, že im napíšem, a tentoraz to bolo od srdca. Odpoveď som od 5. januára nedostal.

Vážená ZSE

Elektrinu od Vás odoberáme už vyše 6 rokov a nemal som v úmysle na tejto skutočnosti nič meniť. To sa všetko zmenilo počas uplynulej hodiny.

Dnes sa u mňa zastavil zástupca vašej spoločnosti, pán G. (Gxxx? Gxxxx? ťažko to rozlúštiť) ohľadom E.Zľavy. Ja som hovoril, že sme neporozumeli celej ponuke na asistenčné služby, ktorá nám už skôr prišla – bola pre nás krajne neprehľadná. Váš zástupca túto vec neriešil, išlo len o ponuku zľavy. Celú dobu sa hovorilo o 4%, chvíľu som to študoval, ale zase som nechcel veľmi zdržiavať.

Myslel som si, že ZSE je totiž seriózna spoločnosť. Váš zástupca o.i. povedal aj to, že ak by som aj prestúpil inam (čo som neplánoval), tak by som prišiel len o zľavu. Toto neviem potvrdiť, keďže dodatkom sa upravuje doba platnosti pôvodnej zmluvy na dobu určitú a musel by som zrejme podrobne študovať aj tú, čo by skoršie ukončenie znamenalo.

Vrcholom všetkého je, že sme rodina s dvomi deťmi v 4-izbovom byte, varíme na elektrike takmer každý deň (malé deti) a naša spotreba je pod 3MWh, čo znamená (ako asi viete) 0% zľavu. Aj pri 4% by som ušetril možno 3 eurá, keďže ide o 3 mesiace (čo zástupca zabudol pripomenúť), aj to nie z celej sumy (na to našťastie upozornil).

Takže kvôli možno 3 eurám (v mojom prípade 0) ma zástupca “serióznej” spoločnosti musí otravovať osobne doma, vysvetlenie dopadov zmluvy zďaleka nedostahuje kvality podpriemerného poisťovacieho agenta a navyše mám teraz zmluvu na dobu určitú, pričom predtým som sa o ňu nemusel a NECHCEL starať.

Reči o tom, že “asi len zisťujú, aký kmeň im ostal”, alebo odpoveď na otázku, prečo nemôžu zľavu prosto len tak priznať v zmysle “obchodníci nemajú prístup k osobným údajom”… už tu som mal začať tušiť problémy. Len kvôli značke ZSE som to podpísal, alternatívneho operátora by som vyhodil dávno, alebo by som si pred ním išiel na Internet vyhľadať názorové články o jeho serióznosti.

Takto si dávam do kalendára na december poznámku, že sa treba poobzerať po inom dodávateľovi elektrickej energie. Možno by som si to rozmyslel, keby ste mi originál môjho dodatku doručili späť a najbližšie ma otravovali s niečím, čo mi naozaj ušetrí peniaze. Takto totiž naopak iba plytváte mojím časom, o trpezlivosti nehovoriac.

S pozdravom

Richard Richter

zák.č. xxxx

Trochu ma to celé prekvapilo, keďže – hoci na Slovensku – na mňa ako už existujúceho zákazníka podobné finty zatiaľ neskúšal ani žiadny operátor internetu či telefónie, ani moja banka, proste nikto.

Mimochodom, dnes už ponúkajú 4% od 2MWh ročne, čo by sa nás už týkalo. Ale nič to nemení na fakte, že ide o jednotky Eur. Takže nechtiac, ale predsa, budem musiet koncom roka riešiť nejakú zmluvu na energiu. A nevidím dôvod, prečo ju zase riešiť so ZSE.

On the brighter side, I managed to finish my quest for system time shifter on JVM that would be usable for testing purposes – all documented in my post. Blogging is not all of course and I am quite happy how topics around Clean Code got some attention around me. We pushed Java Simon project a bit further too, I learned a few interesting things around Spring, MVC and jQuery… Add this beautiful Scala class on Coursera and this year was more than fun after all.

Still I’d like to make some resolutions. I discovered QueryDSL (thanks to a colleague of mine) and this seems to be answer to readable and compile time safe Criteria – because those shipped with JPA2 are simply horrible to read. It works well with IDEA’s annotation processor, Maven and it should be no problem with Gradle either. Ah, Gradle! For around two years I’m watching this guy but for whatever reason I was not able to use it for anything more than a few tests – but that is not Gradle’s fault. I like it, I like the idea, I like the language – and I think this year is time to switch Java Simon from Maven to Gradle. And after that I’ll go on with projects in our company, although the battle there will be more difficult I guess.

Out of technology, I managed to put together a few songs with my colleagues and it was fun – the first time I played in something close to a band. We played only on our company party but it doesn’t change anything… it was a real fun. We didn’t have a drummer so I used my Native Instruments Maschine Mikro and pre-programmed our songs – and I was really happy with the results. I’ll probably dedicate a post to Maschine Mikro, because it is one really interesting controller (and software too!).

Maschine Mikro controller

Talking about music, I managed to upload two full-blown tracks to my Soundcloud and later added two simple guitar+voice tracks. While mixing/mastering is still my weakness, I’m happy that I was able to pull through this recording-wise. And just how I imagined – my songs composed with paper, pen and acoustic guitar many years ago can really work as rock recording too.

So what about this year and those resolutions? Gradle – sure. More testing methodology on our projects – maybe I’ll even manage to document it here on the blog. Pushing Continuous delivery just a bit further again. Scala or other JVM language? I don’t know. Maybe, maybe for tests. And a bit of my music – I need to practice more with keyboard, guitar and bass guitar (yeah, I bought lovely Yamaha bass too).

Bass guitar Yamaha RBX375

Last resolution is no resolution at all – we have to survive somehow “socialistic” experiments of our government here in Slovakia (although there is nothing social about them). Europe has its own deal of problems – and USA? Well they saved themselves from falling down that fiscal cliff or what – just a few hours ago. And it probably means to make the cliff a bit higher for the next time. So we might have escaped one Doom’s day lately at the end of 2012, but who knows how our civilization will fare in the future.

Then I remember those really poor and I know we have nothing really horrible to complain about. So once again – Happy New year – and whole year of 2013!

BTW: Now I see that this is actually sort of continuation of this post.

Phone case: HTC One V

I like Android phones in general. And I like both my Wildfire and One V – however they both have quite funny flaws. Wildfire’s display is unresponsive when I pull it out of my pocket while ringing (that’s why I call back my friends right after I can’t pick them up) and One V – for a change – is very quite in-call. In both cases those are quite crucial phone related issues – and in both cases many people observe the same (but not all). Other than that – on Wildfire (2.x Android) I liked that default HTC clock application showed time of the next alarm and this view was removed from newer OS. Of course One V is faster and better in overall, but still… 3 out of 5 stars. Both.

Partition case: EASEUS Partition Master Home Edition

I wanted some free legal replacement for Partition Magic – and I found this. It may not be all-powered tool for every thing around partitions, but it did anything I wanted and so far never failed. Partitions smaller or bigger? Merge partitions? (Here it actually needs enough space on the partition you are going to merge to for all the files from the other partition – but that’s rather a non-issue.) System copied to my new SSD disk? No problem. Using Windows repair process took much longer after that. 5/5! For free? Yes!

Disc case: SSD drives (Crucial M4 in my case)

Talking about SSD – well, technically it is indeed non-disk, but you know how it goes. SSD generally is fast, of course, but also cheap enough nowadays – so to put there your system volume at least is a really good idea. I did so and my computer runs and starts programs much faster. This is currently probably the best boost you can get for your money. CPU or memory or GPU? Phew… SSD made my computer fleet-footed. I can’t say more really, I somehow decided one day, checked the prices, cross-referenced all the new names for me (like Crucial, never heard of them before!), reviews were good, so I bought this one. And I’m not even having SATA3 on my mobo. 5/5

Java case: Spring JdbcTemplate

When I can I program against standard APIs – like JPA2 instead of Hibernate. When I can. Sometimes you need to go through the select cursor-style and while I could use underlying Hibernate, I decided to go straight for JDBC. And I wrote all the code. With ifs and wheres and parameters. After a couple of hours, I was done, piece was tested and then it hit me! “Man, there is supposed to be that Spring class making it much easier!” JdbcTemplate made the job, I didn’t have to write my ifs twice (first to get the query, then the parameters again), all the exceptions were handled for me and there was even every case you could think about how to process the result set (in my case callback for every row of it). This is how I like stuff made. Documentation clear… actually I mostly just let IDEA to offer me the choices and I made them right there the right way thanks to proper names. Love that. 5/5

JavaScript case: File download plugin for jQuery

Check what this plugin is about – and also its demo. Users sometimes want silly things like “can you disable the button after I press download…” (sure I can!) “…and then after download enable it again?” (are you crazy?!) But you can do it with this plugin based on hidden iframe and a cookie. I had to adjust it a bit because I had a corner case (but quite common) that there were no data and no download, which is third case from user’s perspective in addition to success and (server) failure. I’m no JavaScript expert, on the contrary – but I fell in love with jQuery in the process. And however silly HTTP is for delivering applications, things like jQuery and this plugin make it more bearable (though HTML5 and things like WebSocket mend a lot of my 10-year old concerns). For this plugin and the whole idea – 5/5.

Command-line case: GNU tools for Windows – GnuWin

I never liked all that CygWin heavy-weighted stuff, but GnuWin packages made my day. I just installed them, added c:\Program Files (x86)\GnuWin\bin into my PATH (they all go to the same dir, luckily) and stared cmd just to enjoy grep (package grep), awk (gawk), ls (and many more in coreutils), zip/unzip/gzip/tar/bzip2 and of course sed! Mentioning typical Unix/Linux tools – you may also like (not related to GnuWin) vim, though I’m happy with notepad2 for most cases (read second half of this post). But you never know when you need vim’s macros. But yeah, these are not really command line tools in Windows. GnuWin packages definitely are and they deserve 5/5 for making my life easier.

Windows environment case: Rapid Environment Editor

After so many times heading into System, Advanced, bla-bla, setting the PATH in that super short line I realized “there must be a better way and someone must have already fixed this”. Yes, they have – with Rapid Environment Editor. Adding new paths with this tool is just so much better, it checks whether the path is valid – even with other variables you are referencing (if those are paths, like JAVA_HOME for instance). No more needs to be added: 5/5

Corporate tool case: Planview

For me Planview is just a tool to report my hours. I don’t use its powerful project management features. And every time I need some report out of it I don’t understand the language it is speaking to me. This tool one of those tools forgetting that they are not my only primary tools I use. Honestly, I openly hate it. Terms out of other world, a lot of misuses of the application (not only mine actually), tons of discussion how we should use it – and still we’re not using it the right way. Personally – I blame the tool. I can use Jira, Confluence and many other tools without any problem, but Planview is simply killing me. 1/5 (and yup, it’s IE only)

More-than-a-mail case: Lotus Notes

Lotus – I think this is love or hate thing, but however defended by people who like it, it is still viewed as pain by the vast majority of users. My Lotus for instance doesn’t display mouse cursor in mail editor when it’s not focused window, wrongly shows which tab is selected when two are opened at once, pastes Excel tables is as image by default and there are many other silly defaults. Date you see in trash is trash date, not the date of the message? You can’t reply to mail in your sent mail?! My contacts get often screwed by some cashing I don’t understand and don’t care at all. Not to mention it doesn’t look like normal Windows application (not that I’m a big fan of Windows, but still). Once a colleague closed Notes by accident and I just thought it funny to remark “see, stupid Lotus Notes” – just because whatever bad happens there is kinda Notes’ fault. I read people testifying how Notes rocks, etc. But these people live in the closed world of Lotus. Linux guys can hate Outlook, but it is really usable. Lotus? As a mail and calendar? Not a chance here… 2/5

Blu-ray case: Samsung BD-E6100

Recently I’ve got myself a blu-ray player (finally). I wanted Samsung, because my TV is Samsung, price was alright, I chose model with wi-fi, brought it home and after some initial scare (it didn’t play any disk first, I had to unplug it and after this kind of restart it was fine) I was happy about its performance, speed and everything, especially compared to our older DVD player (newer Philips luckily have remotes for common people too, not only for snipers). I managed to play content from computers (with Serviio installed, though SRT subtitles don’t work unexpectedly) and remote control provided four crucial buttons for TV (on/off, Source, volume up/down) – actually many of buttons from Samsung TV remote work as well (expected). After some time I decided to plug ethernet cable in though, because wi-fi often lost the connection to the router (our notebooks never have the problem, even from the same place). Even with ethernet most of the Smart HUB stuff is quite slow. In overall it was a big upgrade compared to DVD player and I was actually surprised how well it works and plays. And Smart stuff? They still might upgrade it somehow and I didn’t buy it for that anyway. 4/5

Conclusion

Not once I was thinking about myself as a “toiletologist”, because I just think too much about every single flaw of toilets as well. I never could understand why we – mankind – are unable to develop total toilet that always flushes everything, why we again and again put urinals so close together that you can use only 2 of 3 in the end, why we put toilet cubicles with legs on shiny reflective floor, not to mention various silly ways how to screw with automation of flushing, washing, drying or whatever.

Sometimes I want to scream “how could you do such a silly mistake?” But then I realize: “Man, it’s just software, it’s meant to be buggy (not that I agree that much ), the whole computer science is so much younger compared to the building industry – and look what they are able to do in a silly way every now and then. Not only on toilets, but when these are still not ‘debugged’ after all those millennia then what should we expect from the software, hm?”

The more I am happy for technology that really helps and doesn’t “think” that it will be the only thing I need to pay attention to. I have my own real life beyond technology too, after all.

• This cleanest way means to pollute your code on many, many places with your DateFactory – one place where a programmer forgets and you’re screwed. No need to mention how difficult to trace these problems may be, though they are not difficult to locate when you find out what the problem is – because there is only one place where new Date() and/or System.currentTimeMillis() may appear – in your DateFactory class. (Now when I think of it, I’d probably come up with a technical solution to force this pattern, some Java language aware analysis tool searching for exactly these two calls.)
• This DateFactory may or may not be dictated by the requirements – real, inherent ones, not derived from technical needs…
• …actually, in many cases you need to shift time only because of the tests.

When the application somehow implies DateFactory solution, so be it. There surely are systems where it makes sense. In my line of work, however, I messed with some kind of the DateFactory only because of the need to test the system on a specific date, or (in rare cases) to run some highly administrative feature as if it ran on a specific date. While the second case could be just right for the DateFactory, it wasn’t part of our main application code, but rather our migration/preparation/installation utilities and they were never run by the user. So if I had known about any other solution than DateFactory, I’d have gladly welcomed it. I hadn’t then.

Every single time this situation occurred I cursed JVM creators for not adding unified standard way how to mess with system time (guarded by security manager just in case), or some “java” command option, or whatever. My need arises again and again – especially during testing. It’s much harder to prepare time aware data (you have to generate/customize them every time) then declare “you run at this time!” Unless the second thing is impossible of course. But imagine you need to test specific billing job running on New Year’s Day. “Go for the DateFactory you moron!” Yeah, but imagine you have system with @Past annotation from Bean Validation framework. Guess how that one uses your DateFactory? Finally I got the idea – to mock it somehow. Mocking such a thing though is messing with JVM to a degree – as you will see later. Now let’s follow the story as it went…

Solution: jmockit

Actually – I wasn’t the first one. I found that other people wanted to use jmockit library to mock the system time. Jmockit is surely powerful library, more powerful than I can tell, because I actually (sorry to say that) suck in mocking. If you mock System.currentTimeMillis, you’re done (new Date() and all other ways to get the real time use this call). But how to mock this system static native call? Jmockit can do it, and it does it on the side of the callee – which means you don’t need to modify anything else – just set up the mock on the side of System class. During some troubleshooting I tried to use different mock libraries and different approaches, but unless I’m mistaken there are only two ways how to do it – on the caller’s side – or on the callee’s one. Callee is the right side, right? The same way how you have to pollute your code with DateFactory call, you’d have to enumerate, autoscan or whatever else your code in order to mock it on the caller’s side. No way to do this simply and completely when you think about dynamic class loading too and I bet you can throw many other problems on this solution. So I reiterate: *Mock the system time on the callee’s side.* (That is System class, obviously.) Jmockit can do just that.

First we need the class “overriding” currentTimeMillis – here it is (it can be nested class BTW, that’s why it’s static on my listing):

import mockit.Mock;
import mockit.MockClass;
...
   @MockClass(realClass = System.class)
   public static class SystemMock {
       /**
        * Fake current time millis returns value modified by required offset.
        *
        * @return fake "current" millis
        */
       @Mock
       public static long currentTimeMillis() {
           return INIT_MILLIS + offset + millisSinceClassInit();
       }
   }

And now we will use this class:

import mockit.Mockit;
...
           Mockit.setUpMock(SystemMock.class);

Done! From now on all time is changed for the JVM. Or is it? This solution actually has two problems. Let’s deal with the problem numero uno:

Problem 1: you can’t call the original currentTimeMillis

How can you base your shifted time on the real time, when you don’t have the original time now? It would be nice if you just could set the offset and your method simply returned non-mocked millis + the offset. Jmockit can mock the call, but then it is not possible to call the original method without the mock – not for static native calls. So if you use it, you’ll run out of stack in recursion gone wild.

Luckily since Java 5 we have System.nanoTime(). While nanoTime itself is not based on any real world time, we can still use it to determine the time since we set up the mock – if we remember what were nanoTime and currentTimeMillis before we did so – and it can be any particular time, for instance class initialization time:

   private static final long INIT_MILLIS = System.currentTimeMillis();
   private static final long INIT_NANOS = System.nanoTime();

Now it’s easy to tell how might method called from my mock method look like:

   private static long millisSinceClassInit() {
       return (System.nanoTime() - INIT_NANOS) / 1000000;
   }

The only thing you need to do now is to set offset in some meaningful way. I offer my whole solution wrapped in a class straightforwardly called SystemTimeShifter:

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import mockit.Mock;
import mockit.MockClass;
import mockit.Mockit;

/**
 * Class changes the system time returned by {@link System#currentTimeMillis()} via JMockit weaving.
 * <p/>
 * Original System class can be restored any time calling {@link #reset()} method. There are a few ways how to specify modified system time:
 * <ul>
 * <li>setting ms offset via {@link #setOffset(long)}
 * <li>changing ms offset (relatively) via {@link #changeOffset(long)}
 * <li>setting new date, time or ISO date/time via {@link #setIsoDate(String)}
 * </ul>
 * <p/>
 * Any of these methods can be used through system properties (-D) this way (first property in this order is used, others ignored):
 * <ul>
 * <li>{@code -Dsystime.offset=1000} - shift by one second to the future (negative number can be used)
 * <li>{@code -Dsystime.millis=1000} - set system time one second after start of the era (1970...)
 * <li>{@code -Dsystime.iso=2000-01-01T00:00:47} - 47 seconds after beginning of the 2000, alternatively you can set only time (00:00:47, date stays current) or
 * only date (2000-01-01, current time) without 'T' in both cases.
 * </ul>
 * <p/>
 * There must be something that causes class load, otherwise nothing happens. In order to allow this without modifying the original program, one may use this
 * class as a main class with original main class as the first argument (they will be correctly shifted when served to the original class). If no relevant
 * property is specified via -D, nothing happens. In any case (programmatic or main class replacement) this class has to be on a classpath. For application
 * server usage this means it has to be in its system libraries, not in EAR/WAR that is not loaded during the AS start yet.
 * <p/>
 * Example:
 * 
 * <pre>
 * java -Dsystime.iso=2000-01-01T00:00:47 SystemTimeShifter my.uber.appserver.Main arg1 second "third long with spaces"
 * </pre>
 * <b>WARNING:</b> Sun/Oracle HotSpot JVM and its inline optimization may mess up with the mock after it is set up, so if you notice that the time
 * returns to normal after number of invocations, you should add {@code -XX:-Inline} option to your java command line. Other JVM specific options
 * may be needed for different JVM implementations.
 * 
 * @author <a href="mailto:virgo47@gmail.com">Richard "Virgo" Richter</a>
 */
public class SystemTimeShifter {
	/**
	 * System property setting ms offset.
	 */
	public static final String PROPERTY_OFFSET = "systime.offset";

	/**
	 * System property setting "current" millis.
	 */
	public static final String PROPERTY_MILLIS = "systime.millis";

	/**
	 * System property setting ISO date/time (or date, or time).
	 */
	public static final String PROPERTY_ISO_DATE = "systime.iso";

	private static final long INIT_MILLIS = System.currentTimeMillis();
	private static final long INIT_NANOS = System.nanoTime();
	private static long offset;

	private static boolean mockInstalled;

	@Deprecated
	protected SystemTimeShifter() {
		// prevents calls from subclass
		throw new UnsupportedOperationException();
	}

	static {
		String isoDate = System.getProperty(PROPERTY_ISO_DATE);
		String millis = System.getProperty(PROPERTY_MILLIS);
		String offset = System.getProperty(PROPERTY_OFFSET);
		try {
			if (isoDate != null) {
				setIsoDate(isoDate);
			} else if (millis != null) {
				setMillis(Integer.parseInt(millis));
			} else if (offset != null) {
				setOffset(Integer.parseInt(offset));
			}
		} catch (NumberFormatException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Bootstrap main to allow time shifting before actually loading the real main class. Real
	 * main class must be the first argument, it will be removed from the list when calling the
	 * real class. Without using any relevant -D property there will be no time shifting.
	 * 
	 * @param args argument list with original (desired) class as the first argument
	 * @throws Exception may happen during the reflection call of the other main
	 */
	@SuppressWarnings({"unchecked", "rawtypes"})
	public static void main(String[] args) throws Exception {
		String[] newArgs = new String[args.length - 1];
		System.arraycopy(args, 1, newArgs, 0, args.length - 1);

		Class clazz = Class.forName(args[0]);
		Method main = clazz.getMethod("main", newArgs.getClass());
		main.invoke(null, (Object) newArgs);
	}

	/**
	 * Sets the new "system" time to specified ISO time. It is possible to set exact time with the format {@code yyyy-MM-dd'T'HH:mm:ss} (no apostrophes around T
	 * in the actual string!) or one can set just time
	 * (then current date stays) or just date (then current time stays).
	 * <p/>
	 * If parse fails for whatever reason, nothing is changed.
	 * 
	 * @param isoDate String with ISO date (date+time, date or just time)
	 */
	public static synchronized void setIsoDate(String isoDate) {
		try {
			if (isoDate.indexOf('T') != -1) { // it's date and time (so "classic" ISO timestamp)
				long wantedMillis = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").parse(isoDate).getTime();
				offset = wantedMillis - millisSinceClassInit() - INIT_MILLIS;
			} else if (isoDate.indexOf(':') != -1) { // it's just time we suppose
				Calendar calx = Calendar.getInstance();
				calx.setTime(new SimpleDateFormat("HH:mm:ss").parse(isoDate));

				Calendar cal = Calendar.getInstance();
				cal.set(Calendar.HOUR_OF_DAY, calx.get(Calendar.HOUR_OF_DAY));
				cal.set(Calendar.MINUTE, calx.get(Calendar.MINUTE));
				cal.set(Calendar.SECOND, calx.get(Calendar.SECOND));
				offset = cal.getTimeInMillis() - millisSinceClassInit() - INIT_MILLIS;
			} else { // it must be just date then!
				Calendar calx = Calendar.getInstance();
				calx.setTime(new SimpleDateFormat("yyyy-MM-dd").parse(isoDate));

				Calendar cal = Calendar.getInstance();
				cal.set(Calendar.DAY_OF_MONTH, calx.get(Calendar.DAY_OF_MONTH));
				cal.set(Calendar.MONTH, calx.get(Calendar.MONTH));
				cal.set(Calendar.YEAR, calx.get(Calendar.YEAR));
				offset = cal.getTimeInMillis() - millisSinceClassInit() - INIT_MILLIS;
			}
			mockSystemClass();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Sets ms offset against current millis (not against real, instead changes current value relatively).
	 * 
	 * @param offset relative ms offset against "current" millis
	 */
	public static synchronized void changeOffset(long offset) {
		SystemTimeShifter.offset += offset;
		mockSystemClass();
	}

	/**
	 * Sets ms offset against real millis (rewrites previous value).
	 * 
	 * @param offset new absolute ms offset against real millis
	 */
	public static synchronized void setOffset(long offset) {
		SystemTimeShifter.offset = offset;
		mockSystemClass();
	}

	/**
	 * Sets current millis to the specified value.
	 * 
	 * @param timestamp new value of "current" millis
	 */
	public static synchronized void setMillis(long timestamp) {
		offset = timestamp - INIT_MILLIS;
		mockSystemClass();
	}

	/**
	 * Resets the whole System time shifter and removes all JMockit stuff. Real system call is restored.
	 */
	public static synchronized void reset() {
		Mockit.tearDownMocks(System.class);
		mockInstalled = false;
		offset = 0;
		System.out.println("Current time millis mock REMOVED");
	}

	private static void mockSystemClass() {
		if (!mockInstalled) {
			Mockit.setUpMock(SystemMock.class);
			System.out.println("Current time millis mock INSTALLED: " + new Date());
			mockInstalled = true;
		} else {
			System.out.println("Current time millis mock probably INSTALLED previously: " + new Date());
		}
	}

	public static boolean isMockInstalled() {
		return mockInstalled;
	}

	/**
	 * Handy if you set up the mock by some other means like {@link Mockit#setUpStartupMocks(Object...)}.
	 *
	 * @param mockInstalled true if you want to pretend that the mock is already in place (or is/will be installed otherwise)
	 */
	public static void setMockInstalled(boolean mockInstalled) {
		SystemTimeShifter.mockInstalled = mockInstalled;
	}

	/**
	 * Returns real time millis based on nano timer difference (not really a call to {@link System#currentTimeMillis()}.
	 * 
	 * @return real time millis as close as possible
	 */
	public static long currentRealTimeMillis() {
		return INIT_MILLIS + millisSinceClassInit();
	}

	private static long millisSinceClassInit() {
		return (System.nanoTime() - INIT_NANOS) / 1000000;
	}

	@MockClass(realClass = System.class)
	public static class SystemMock {
		/**
		 * Fake current time millis returns value modified by required offset.
		 *
		 * @return fake "current" millis
		 */
		@Mock
		public static long currentTimeMillis() {
			return INIT_MILLIS + offset + millisSinceClassInit();
		}
	}
}

I’m not suggesting it’s a masterpiece of engineering – but it works pretty well and you can set up the offset in many handy ways (just the date/time, both, offset in ms, you name it), you can use it as the main class before you start some other real main class (this way I started the whole application server in completely different time – Weblogic 12c in my case, but I think it doesn’t really matter). But I did mention two problems, right?

Problem 2: After some time the time returns to normal!

This problem quickly manifests on Sun’s JVM (can’t tell about others) and I found this non-solution: http://code.google.com/p/jmockit/issues/detail?id=43

At least originally it was no-go for me as the suggested solution was -Xint – using interpreted JVM. This made tests unbearably slow, nobody would run them! I felt I’m pretty close to the solution and thanks to Rogerio Liesenfeld (jmockit author) and my private conversation with him above this issue I got pushed into the right direction. Sure, first I tried other mocking libs, but then I got back to jmockit (because it mocks the target, not the source of the call) and I tried again. I focused on what Rogerio wrote in his comment #7 (which was actually his reply to my mail). “So OK, if it’s HotSpot optimization, can’t I disable just that one? Even for that single class?” While I could not disable it for the class with Sun’s HotSpot (and I don’t know if it is any problem at all on different JVMs) I could disable it globally with -XX:-Inline. And yes, it’s much much faster than -Xint. Generally it should not be much slower than 1.5x of normal run with inlining – this depends on many factors of course (on overall “inline-likeness” of your application/test), but it’s much better than typical 10x penalty for interpreted JVM.

Problem 3: TestNG integration

Ok, I lied about two problems only – but only because this one is beyond the system time shifter itself. This problem was caused by my lack of understanding of jmockit and its interaction with TestNG. I wanted to shift my time for the whole TestNG suite without realizing that jmockit/TestNG may have their own agendas too. I tried to run my code with @Before/AfterSuite setting up my mocked time with SystemTimeShifter.setIsoDate(…) call and tearing it down again with reset(). But it didn’t work inside the test methods anyway, because something uninstalled my mock before the test method was run. Cedric from TestNG told me it’s jmockits business and Rogerio told me I’m using it the wrong way because it was never meant to be run this way for the whole Suite. I could use it around class or even method call, but I didn’t like the idea of time being shifted to the same point for every single method. I didn’t like the idea, that I can’t tell from log files how long the test is running (though the log file times were shifted too, I hope you don’t mind ). Silly on my part, however, this should work for you just fine:

   @BeforeSuite
   public final void setupSystemTime() {
       SystemTimeShifter.setMockInstalled(true); // because of the setUpStartupMocks further, which sets up the mock
       SystemTimeShifter.setIsoDate("2011-10-14T10:00:00"); // this set's the offset - but doesn't set up the mock (thanks to the assert above)

       // this line performs all the suite scope magic
       Mockit.setUpStartupMocks(SystemTimeShifter.SystemMock.class);
   }

   @AfterSuite
   public final void resetSystemTime() {
       SystemTimeShifter.reset();
   }

While technically the AfterSuite part is not necessary, it is cleaner this way. Jmockit uninstalls his part by itself, but time shifter doesn’t know about it. This way it got reset as well.

Conclusion

There it is – not perfect and not without little hassles (-XX:-Inline namely), but working fine so far, at least for my cases. In my eyes – this is really tragic fault of the current JVM date library, fault that cannot be mended easily. System.currentTimeMillis is the only relevant source of real time and unless we can mess with it somehow in a clear way we will always have need to mess with it in ugly ways. This reminds me of the t-shirt I have. There is a stargate like ring on it, it is just named “TIME GATE” – and Java Duke comes out of it, opening the future for us. I’m curious a bit how he could do it. Did he cheat on JVM somehow too? When will we have clean solution that makes any DateFactory rather obsolete? Will we ever? Or do we have to unlock the future with TimeShifters in such obscure ways? Java, Java…

Let me know your story with system time cheating. I know I haven’t talked about setting the computer system time. That is simplest solution for many occasions, but not for running the tests on Continuous Integration server shared with many other projects, so I just omitted this altogether. If you have any success story with SystemTimeShifter, if it helps you somehow, please, be so kind and let me know to lift up my spirit.

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.

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.

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!”

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.

It was three years back (January 13th, 2009) when I posted on our Webnode site that we need some better web for presentation than our project site on Google Code. But then we found we can’t post bunch of HTML files (Javadoc) on Webnode – and with mime-types SVN props we can do that on Google Code… oh, how quickly things change.

Webnode site could be good if Java Simon gained some bigger momentum on our side – more committers and contributors, people writing blogs or tutorials or success stories (or not so success stories too if they can help ). But this did not happen and I felt as rather annoying obligation to update this site. Especially because the edit functionality is on a separate URL – editing a Wikipedia page or a blog post on WordPress is always just one click away – but not so on Webnode.

Three years later I decided to redirect javasimon.org on our Google+ page because it is so much easy to update, posting even very short posts is not inappropriate (which would be on a blog) and it’s just so much closer to my way of living on the Internet right now. I’ll go through javasimon.webnode.com and it will soon be a matter of past.

Last time I discussed some changes from version 1 to version 2. And to preserve the little from Webnode site that has any “historical” value I hereby copy one blog post covering just these differences:

Major changes in the core of the Java Simon v2
2009-01-28 14:30
While there are some important extensions to the Java Simon (JMX, Spring integration, etc.) there are a few important changes in the core part of the API that are probably even more important. If you’ve already managed to use Java Simon 1 I strongly suggest that you use version 2 even in its alpha stages. The thing is:

• If your project is finished or close to finish (month or two) stay with version 1.
• If your project continues and you’re just experimenting with Simon, definitely use version 2! There is v2-alpha1 which is basically rework of the v1 after a few changes in Stopwatch. If there is newer alpha out (check Featured Downloads on the right on our project page) take that one of course, because it contains more features from v2.
• Version 2 is planned to be out during March or April 2009, which is really soon.

Now what are the changes and why we made them?

• Important change happened in the Stopwatch. While in the v1 it contained various start/stop methods that took care of multi-threaded environment now it has only one start method and this start doesn’t return this anymore but it returns new Split object instead. You have to take care of the Split object, you have to take care of your multi-threading, you have to call stop method on the Split. This makes our code safer as the Stopwatch doesn’t contain internal maps that were prone to memore-leaks if client forgot to stop some split. Thanks to Erik van Oosten and his great Java Simon evaluation.
• Based on the same post we changed sample methods so that they return Java Bean objects now instead of the field.
• While in v1 you had to use SimonManager now you can use non-static Manager implementation directly. SimonManager still stays your favourite convenient class full of static methods, of course. This allows to have multiple separeated Simon hierarchies which may be handy in Java EE environment.
• To provide some extensibility for the API we introduced Callback interface. This allows to hook onto various events and process these events in any way you want – to log them, send JMX notifications, whatever.

There are more features to come with version 2 and I covered only those in the core part of the API. Stay tuned, download, use, test, let us know what you think.

Now let’s take a look at those Callbacks. Based on good-old Observer pattern, Callback is a listener that performs some actions on various events. First question was where the Callback should be registered – and we decided that Manager will hold its Callbacks. We didn’t want to scatter Callbacks across various Simons because typical usage would lead to a situation where many Simons call (and point to) the same Callback. We rather decided we will centralize Callback management on a Manager (that is per Manager of course) and bring some way how to filter events based on Simon name for instance.

Simple example of Simon is in our CallbackExample:

    SimonManager.callback().addCallback(new CallbackSkeleton() {
           public void onStopwatchStart(Split split) {
               System.out.println("\nStopwatch " + split.getStopwatch().getName() + " has just been started.");
           }

           public void onStopwatchStop(Split split) {
               System.out.println("Stopwatch " + split.getStopwatch().getName()
                   + " has just been stopped (" + SimonUtils.presentNanoTime(split.runningFor()) + ").");
           }
       });

       Stopwatch sw = SimonManager.getStopwatch(SimonUtils.generateName());
       sw.start().stop();

When you work with Simon (last two lines) you don’t care about Callbacks – they will be called. Their configuration can be based on some configuration and they should do whatever you want to hook on various Simon events.

BTW: If you use Java Simon 3.1 method onStopwatchStop is still called stopwatchStop. This is quite serious flaw and poor choice of method name on my part (and I’m terribly sorry for that). While this method doesn’t show it clearly, there was another method – clear (now onManagerClear). This method is called – as you may guess from the new name – when clear method on the manager is called. Let me explain composite callbacks first to show you the whole problem…

To add more callbacks to the manager is all right but if you want to filter Simons (by name, for instance) that fire an event on a Callback you actually need to do it in the event itself. Or wrap the Callback into another one – that is exactly what FilterCallback idea is all about. Another thing is that you may need to call various callbacks for the same filter – to group them – and that is what composite callback does – holds more callbacks (children) and relays the event to all of them. There is no interface CompositeCallback – instead all these methods are on Callback already, but they are not implemented in the CallbackSkeleton for instance (used in the example above). There is one implementation called CompositeFilterCallback – and you probably can guess what it does. It can hold more callbacks and call them when the common configured filter is passed. See CallbackFilteringExample for simple use case.

Now guess how people tried to remove callbacks from composite callback. It’s just a collection of callbacks after all, right? Ah, method “clear” must do exactly what I need here. But it didn’t. And if you didn’t implement this event method (which is not very common, but JmxRegisterCallback is nice example where it is very handy) it simply did nothing. There was method to remove one callback, but not all of them (this one was in SimonUtils). This is all finally fixed with version 3.2 – all names are much better and removeAllCallbacks is in the Callback interface.

JMX is nice example why we needed callbacks just as much as we wanted to offer them to our users. There are two ways how to access Simons via JMX – you can use single point MX bean, or let Simon instantiate MX beans per Simon. The latter however requires some actions when Simon is created, destroyed or the whole manager is cleared. I mentioned JmxRegisterCallback already – check how it’s done there. Now the Simon manager knows about Callback mechanism – but it doesn’t have to know about JMX – or anything else you want to drive by these events.

Split introduction and Callbacks are two very important changes that happened in version 2 – and these things are now well proven and will probably last (though some names can change as will happen in version 3.2 ). Next time I’ll try to wrap up the rest of the story.

I’m really proud about our newest Java Simon release (3.1.0) and I decided to share the mail written to javasimon@googlegroups.com also here on my blog:

Dear Java Simon users

Firstly – version 3.1.0 was released on New Year’s Day – more about it
on our project site:
http://code.google.com/p/javasimon/

We announced it also on our new stream on Google+ (it should be
available for non-google users too):
https://plus.google.com/b/115141838919870730025/115141838919870730025/posts/ZpmYGp9F2yp

Secondly – about Google+ – we decided to pull down our Webnode site
because it was a bit cumbersome to maintain and add new posts there.
Instead we are moving to the aforementioned Google+ page.

Direct link: https://plus.google.com/115141838919870730025/posts
Short link: http://gplus.to/javasimon
Or just use our domain! http://javasimon.org/ or http://www.javasimon.org/

This way it should be easier for us to post more often even smaller
facts about your favourite monitoring library.

Thirdly – Happy New Year to you all, update and share your thoughts, I
feel very well about the last release. We’re working on 3.2 already,
with our new commiter (Gerald) we should be able to deliver simple
embeddable web console too, so there is a lot to be looking forward
to.

Best regards and wishes

Richard “Virgo” Richter

You are welcome – and encouraged – to add Google+ page into your circles of course. And once more – Happy New Year – as this is my first post here in 2012.

If you blog on WordPress you probably got the mail too. It was just lovely dot after the whole year on the Internet. Especially with sentences like “your writing has staying power”. That made my day. Here it goes – full of it is behind the link at the bottom:

The WordPress.com stats helper monkeys prepared a 2011 annual report for this blog.

Here’s an excerpt:

The concert hall at the Syndey Opera House holds 2,700 people. This blog was viewed about 26,000 times in 2011. If it were a concert at Sydney Opera House, it would take about 10 sold-out performances for that many people to see it.

Click here to see the complete report.

PS: I forgot to mention that my wife’s blog about cooking – in Slovak only! – made three times bigger numbers. With only two new posts this year she reportedly sold out Medison Square Garden three times (I was rather compared to Sydney Opera – another nice touch of the report).

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 Live + 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.

Working on our first version of Java Simon I learned a lot from my colleagues too. While we shared our views all the time on the OSS library we somehow did even better than on our common (resource limited) projects. We also knew that library must be even cleaner and better than some Information System developed once – often without proper support budget. One guy insisted on finals whenever possible (which I’m not fan of) and he also vigorously refactored methods with boolean flags – and I originally disliked this change. In Simon interface we had methods like:

Map<String, String> sample(boolean reset);

Now we have much cleaner two methods instead of using boolean parameter – not to mention that we have Sample object instead of Map used in early versions:

Sample sample();
Sample sampleAndReset();

Not that we don’t have any method with boolean flag – but the most prominent one is rather management one compared to sample methods:

void setState(SimonState state, boolean overrule);

Generally I don’t like using boolean flag parameters because they are hard to read when you see just plain code. If they are replaced with enums (where suitable) readability goes up instantly. If they are split to two methods – especially when one of them is rather default (like the sample without reset) – even better.

Working on an OSS library (or any other library – even a private one) you have to think way harder (or rethink more often) how to organize your interface, packages and all. I personally hate backward compatibility as an ultimate decision and we knew that we will change the interface here and there. If you want to upgrade then just go through your code and change those few things you have to change! Or don’t upgrade. (I’ll not go on about the whole myth of compatiblity and how often it is not completely true.)

That’s why we decided to release version 1.0 quite soon (December 2008, we started the project in August 2008) and find out what is missing. Version 2.0 followed quite quickly – in January 2009 we had the first alpha (quite stable though) and we decided to focus solely on this without any support for 1.0. The reason was that the Stopwatch behaviour changed quite a lot – for the better.

In 1.0 HalloWorld looked something like this:

SimonStopwatch stopwatch = SimonFactory.getStopwatch("org.javasimon.HelloWorld-stopwatch");
stopwatch.start();
System.out.println("Hello world, " + stopwatch);
stopwatch.stop();
System.out.println("Result: " + stopwatch);

Most important feature was that both start and stop were called on the Stopwatch. Now you may wonder what would happen if you started stopwatch twice and stopped it twice as well. It depended… though – honestly – I don’t remember exactly. Stopwatch had thread-local variable that remembered start timestamp (nanoseconds of course) and stop was expected to be called in the same thread. Double start and stop was illegal operation. Now this implied two serious limitations. The first was potential memory leak on the thread-local variable if you (client programmer) failed (or forgot) to stop the stopwatch. The second was that you couldn’t stop the stopwatch in a different thread.

This was troublesome design and happened to be resolved soon after 1.0 release. Our new HelloWorld looked (and still looks) like this:

Stopwatch stopwatch = SimonManager.getStopwatch("org.javasimon.examples.HelloWorld-stopwatch");
Split split = stopwatch.start();
System.out.println("Hello world, " + stopwatch);
split.stop();
System.out.println("Result: " + stopwatch);

Now the client programmer is fully responsible for working with the Split, there is no thread-local and the worst thing that may happen to the stopwatch is that its “actual” count will go up and up (and so indicate some problem with missing stops). Split will be garbage collected – unless stored by the programmer (his fault anyway ).

Another important features coming with 2.0 were JMX support (MX Bean) and Callbacks – these allowed programmer to hook on various events. But more about these in my next post, right?

JAMon guys used Jarep to store and graph results and what I liked the most was the story how these results available over a long time helped them when they needed it. Story went something like: “We found out that the performance of our web-shop started to be unacceptable sooner then originally calculated. Graph showed us that there was sudden jump half a year ago and since then the application performed worse. Luckily we had also work plan from IT stuff that revealed that the same day new JDBC driver was installed – and that was the reason.” Bottom line – without data you just don’t know. I liked that and it went pretty much along the lines Kirk Pepperdine says all the time – you need proof, you need data, you just need to know – don’t guess. Actually most wise people say that, but I remember Kirk and also that JAMon/JARep story when it comes to performance and monitoring.

A colleague of mine tried to use JAMon for our work project but he was not happy about the API. He was missing some management hierarchy – and that’s how idea of a tree hierarchy (not much different from java.util.logging for instance) for Simons started. Another issue was timer based on ms (JAMon is compatible with J2SE 1.4), I didn’t like that at all. So many things may happen in a single ms – not to mention most Windows changed the timer ever 10 or 16 ms. We decided to write our stopwatch facility and over one August weekend I wrote some basics (our first commits) and we started building on it. We can’t measure anything – like JAMon tries – we focused solely on Stopwatch and Counter. Three years later I’m happy about it – Stopwatch being probably 90% (or more) of all used Simons. Originally I wanted to give our users some way to add another kinds of Simons, but soon I realized how messy it would all become.

JAMon was in version 2.7 when we started the Simon project and the page looked exactly how it looks right now. We finished the first version in December, we were happy about most of it, we cared for the code and for the Javadoc too – and I think it was really obvious from the look at the project. These are ideas we still care for and quality Javadoc is undisputed part of the project.

TSS press release: Java Simon 1.0, monitoring API, released

Simon gained some initial attention and one particular developer even blogged a few times about us – check Evaluating Simon – Java monitoring or other Erik’s posts related to monitoring. Funny – later I’ve heard the name Erik van Oosten mentioned by my colleagues working with Wicket, but I’m 2 years ahead of the story. That’s just how it is with active people. His posts were most appreciated and he also provided AOP based Spring integration. Now – years later – even I use it in our current project (though it went through a few fixes, but the code is essentially still Erik’s).

Soon we discovered that the first version had a few serious issues and redesign was necessary. But more about that in the next installment some other time.