watch 'echo "show processlist" | mysql -u whateveruser --password=mypassword | grep -v "show processlist" '

Now run it and you will have a poor man's monitor, kind of like top but for MySQL. That coupled with screen (or multiple terminals) may give you some quick and easy piece of mind.

This should give you *a lot* of monitoring automation ideas. It should be easy to put together a shell script that puts it all in a little "important things panel" to use watch on. Sometimes that's all you need.

[From Speed Up Firefox web browser | Ubuntu Geek]

I love my Mac, and many of us like the idea of automating our software, until we try to use AppleScript to do it. To say that Applescript is professional developer unfriendly is an understatement. I like ruby but to make ruby and applescript talk requires sending strings to osascript in just the right way and getting the output from osascript back. Not a lot of fun at all.

Enter appscript. Appscript is a ruby library that interfaces with applescript seamlessly.

What's pretty amazing is its power after you spend a little while on the irb console and keep using the tab key for autocompletion. It even introspects the dictionary to see what is available at this time. It doesn't always give the right thing but by trying things out and with a bit of logic you always get there.

There's also an app called ASDictionary that will spit out the dictionary with ruby syntax, though I never found the dictionary all that useful anyway (I mean yes, it has definitions for everything, but it seldom provides info on exactly how everything is tied together or examples of use). I personally prefer trying things out on the console.

Here are a few examples of its use. You can do all this on irb immediately after installing it with sudo gem install appscript:

Driving iCal

This will get all your calendars and print their names:

 
require 'appscript'
app = Appscript.app("iCal")
app.calendars.get.each { |cal| puts cal.name.get }
 

Just expanding on this concept a little more, you can also grab all the to-dos:

 
app.calendars.get.each { |cal|
  cal.get.todos.get.each {|todo|
    puts todo.summary.get
  }
}
 

Automating Safari. Ruby to Applescript to Javascript

Haven't tried marshaling values back as I'm just exploring, but I don't see why it couldn't.

 
require 'appscript'
app = Appscript.app("iCal")
app.open_location("http://www.google.com")
window = app.documents.get[0]
window.do_JavaScript("window.alert('Your title is '+document.title)")
 

I'm sure you can find some use for this. I already did - I wrote myself a quick cron to add all the JIRA tasks assigned to me to Omnifocus if I don't already have them there. I'm looking forward to seeing what else I can put this to use.

This really depends on what type of data you are dealing with. Data types that are mostly read (news, notices, articles) probably benefit from whatever caching you can provide, while areas of data that change a lot (shopping carts, server status records) probably won't benefit from caching at all.

Here are the concurrency strategies on hibernate caching explained:

technorati tags:
hibernate
java

• Transactional: Full Transaction Isolation, even repeatable-read. This is not particularly fast, but it does guarantee full transactional isolation.
• Read-Write: A bit more relaxed than transactional, it uses a timestamp to maintain Read-Commited transaction isolation.
• Non-Strict Read-Write: With this one, you start ending up with stale data, because since it is not strict it provides no guarantee of consistency. If you think things may be updated and provide you with stale data, set a short timeout for expiration.
• Read-Only: Use this one for Reference data that never changes (days of months, cities, states, etc).

Note that, on hibernate, the concurrency strategies available will depend on your cache provider. Also note that all caching only focuses on things your application updated. If you have other applications also updating data on the same database consider not using caching at all for those classes.

If you insist on using caching in this situation, be prepared for caching errors on production and be ready to do some cache management - provide a way to look into the cache statistics and clear the cached elements, and use timeouts that are sensible.

Finally, caching should be your last option for performance, not your first. I can't tell you how many times I've seen teams want to mess around with the cache settings when they have queries so bloated that would make Windows Vista blush. Fix your query issues first, then apply caching. If you add caching when you haven't fixed underlying query problems you only accomplish two things: Sweeping your problem under the rug (but you can still see the bump), and cause OutOfMemory errors.

Category: Best Practices

1. What was expected
2. What actually happened

Translation: assertTrue should always, always have a message.

Consider the following:

 
assertTrue(mv.getViewName()
    .startsWith(myController.getSuccessView()));
 

This will only return "assertion failed". Which is great, but how do we know what happened? If this is buried on one of the lunt automated remote builds, how am I supposed to know what is going wrong? Which is the expected? What actually happened?

A much better version of the same looks like this:

 
assertTrue(
    "Was expecting something like "
        + myController.getSuccessView() + " but was "
        + mv.getViewName(),
    mv.getViewName()
        .startsWith(myController.getSuccessView()));
 

Same assertion, but now it tells me more specifically what's going on and I can fix bugs with it. Once I set this on the test, it becomes easy to see what was going on.

I recently had a Saturday with some other Bay Area developers where we did a lot of thinking about testing, so expect some more advice in the future as I collect my notes.

Remember the goal of unit tests is to "find bugs" (thanks Harry!). An assertion without an associated message merely notifies you that a bug occurred but doesn't actually "find it". As you are writing your unit tests, make sure you find it as well.

technorati tags:testing, junit, assertions, java

Via TheServerSide:

Wazaabi includes a GUI framework that brings XUL to Eclipse RCP plugin developers and a set of components that link the client-side XUL based viewers and forms to server-side business components. Thus, rich client developers can use XUL to code a GUI, rather than using SWT.

Wazaabi brings XUL to Eclipse RCP based rich client applications

This is an actual XUL viewer, not a similar syntax like XSWT or similar attempts. They use servlets to communicate between the XUL side and your application, to keep the flexibility of sending the XUL to a mozilla browser. Very interesting.

technorati tags:java, xul, eclipse

• Eclipse Checkstyle - http://eclipse-cs.sourceforge.net/update
• Spring IDE - http://springide.org/updatesite/
• Fitnesse by Band XI - http://www.bandxi.com/fitnesse/
• Subversion for Eclipse - http://subclipse.tigris.org/update_1.0.x
• Memory Monitor - http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-ui-home/updates
• Mylar - http://download.eclipse.org/technology/mylar/update-site/e3.2 (or e3.3)

Also, here's some stuff that I like to install manually:

• JSEclipse - no offense to the WTP folks, but their JS editor is not that great. This one can understand OO javascript, common ajax libraries, JSDoc and more.

technorati tags:eclipse, plugins, java

Let me be blunt: In the past, creating graphical editors within Eclipse using the Graphical Editor Framework (GEF) was slow and painful. It involved understanding a complex framework and quite a bit of redundant code. That said, GEF is an excellent framework for creating graphical editors because it is model-agnostic. On the other hand, being model-agnostic creates its own problems.

Learn Eclipse GMF in 15 minutes

In this article, Ted Bergeron shows you how to use the Validator component of Hibernate Annotations to build and maintain validation logic easily in your Web apps.

Hibernate can meet your validation needs

technorati tags:java, validation