So, given that HipChat has a rockin REST API, I thought I’d put together a little bit of JavaScript that ties up all the loose ends and gives me a nice mile-high display for displaying HipChat messages on the team plasma. And thus HipWall is born!

In the pic about I’ve connecting the HDMI port on an Acer A501 Android Tablet to display my little HipWall page on the big screen.

Useful Tools for RESTful Tinkering

I’ve been looking for a good Chrome plugin to test out RESTful services and I’ve found one that I love – Postman REST. This little tool lets you easily plugin in URL params and headers, and looks after pretty printing and history management to boot. Really sweet. Saved me a ton of time tinkering with the HipChat API.

Mocking out those AJAX calls

I’ve been getting into QUnit for my JavaScript unit testing, and I’m having a ball. One thing I’ve never explored, however, was mocking out RESTful services. Enter MockJax - an awesome jQuery plugin for handling mocking of RESTful calls (good tutorial here).

Needless to say, it’s very handy to be able to setup mock return values doing snazzy magic like this:

module("Remote HipChat Mocked Calls", {
	setup: function() {

		$.mockjax({
		  url: /.*\/rooms\/list.*/,
		  responseTime: 150,
		  responseText: getRoomsMock()
		});

		$.mockjax({
		  url: /.*\/rooms\/history.*/,
		  responseTime: 150,
		  responseText: getHistoryMock()
		});

	}
});

Huge timesaver. Can test our all my stuff with canned values and I don’t even need to muck about with API keys and whatnot.

Getting Jiggy with Sweet Google Fonts

This is also my first chance to have a good play with Google Web Fonts. In the sample, I use Yanone Kaffeesatz which I’ve always loved since seeing Zac Holman’s rocking slides. If you haven’t played with them before, they are definitely worth a look. Add a link

<link href='http://fonts.googleapis.com/css?family=Yanone+Kaffeesatz' rel='stylesheet' type='text/css'>

Then style away:

.chat {
	font-family: 'Yanone Kaffeesatz', sans-serif;
	height: 23%;
}

Nice!

Add a touch of Date love

This was also a good chance to have a look at moment.js – a very cool JavaScript date library that can used for a range of parsing and presentation love. I was interested in those “human-friendly” type dates – “12 minutes ago…” and it supports them out of the box! Lovely.

var timestamp = moment(element.date);
$('#chatlist').append("<div class='chatauthor'>" +
				timestamp.fromNow() + " by " +
				element.from.name + "</div>");

Very sweet. Good time-saver!

Time to Battle Test!

This Friday we’ll take it for a spin in a live hackathon scenario. When I work out a few of the kinks, I’ll throw it up on Github!

So I’m experimenting with a new workflow where I disable the network card on my PC , and just come online every few hours to clear the mailbox.  It’s been quite a liberating experience so far.

Tooling Up

Initially I had a good surf around for tools that might fit the bill to help with my new disconnected life. There’s some nice Windows tools like Cold Turkey to keep you off social networking sites, and Freedom to keep you off the web altogether, but I was really just after something lightweight to turn off my Windows 7 network card!

Scripting a Win

Turns out that the easiest way is to script up the netsh.exe tool that comes with Windows. With this bad boy, nicely discussed on this blog, I was up and running with a quick “online.bat” and “offline.bat” and was living the disconnected life. That magic shell command you need to disable your adaptor is:

netsh interface set interface "Local Area Connection" DISABLED

And of course, you’re back online with:

netsh interface set interface "Local Area Connection" ENABLED

Looking forward to reporting on my productivity wins with this new less-connected life!

Lots of our customers are “Microsoft Shops” from soup to nuts – SQL Server, Active Directory, Internet Explorer – you know the drill. So we’ve been working hard to make our Grails-based offering run just lovely alongside existing Enterprise apps.

Grails and SQL Server

First things first, we’ll need a SQL Server JDBC driver so we can play nice with common SQL Server versions (viz. 2005/2008R2). We evaluated a couple of Microsoft SQL Drivers including: the Microsoft One, and the jTDS one. Both worked fine, but we ended up going with the jTDS one since it seemed faster in our smoke testing. And it was in a Maven repo.

jTDS DataSource Configuration

We experimented for this for for quite some time to get everything just so, so I’d thought I’d take some notes for you to to lean on. First of all, if you’re going dataSource config, you’ll want something like this:

dataSource {
	pooled = true
	dialect = org.hibernate.dialect.SQLServer2008Dialect
	driverClassName = "net.sourceforge.jtds.jdbcx.JtdsDataSource"
	url = "jdbc:jtds:sqlserver://yourhost:1433/GMARC;useNTLMv2=true;domain=yourDomain"
	dbCreate = "none"
}

There are some excellent docs on the URL Formats for jTDS but I found the useNTLMv2 switch was essential in the client’s environment. Apparently v1 (the default) is full of security holes, and there are standard NT group policies that disable NTLMv1 entirely. I also found that the domain switch needed to be provided otherwise we were hosed.

Going Managed

If you’re walking the Tomcat-managed DataSource, you’ll need to use the matching context.xml version of the above:

<Resource name="jdbc/gmarc" auth="Container" type="javax.sql.DataSource"
        driverClassName="net.sourceforge.jtds.jdbc.Driver"
        url="jdbc:jtds:sqlserver://yourhost:1433/GMARC;useNTLMv2=true;domain=yourDomain"
        maxActive="20"
        maxIdle="10"
    	validationQuery="select 1" />

Then, of course, you’ll make your configuration datasource of the JNDI variety… Perhaps something like

dataSource {
    jndiName = "java:comp/env/jdbc/gmarc"
}

One of the advantages of using the Container-managed variety of DataSources is that you can run somethink like PSI-Probe (a fork of the old Lambda probe) to validate your data source connections without going anywhere near your Grails config. Useful stuff. We’ll do more of that.

A Note on SQL Server Port Weirdness

If you’ve had a few SQL Server installs concurrent on your Dev box, the SQL port will move off the standard 1433 and onto some random port. We’ve had issues on our dev machines with this one, so head in the SQL Server Config Manager, have a look at the Network Configuration/Protocols/TCPIP then scroll to the bottom of the IP Address and find the TCP Dynamic Ports setting you need. What a snack

Integrated Security & Sticking Files Where They Belong

You’ll notice neither of the above has username or passwords. Most SQL Server Admins despise Mixed Mode security (where you setup special usernames and passwords inside SQL Server itself). Microsoft has gone to the trouble of writing security white papers telling you to turn off Mixed Mode, so Integrated Security is your best friend in most MS enterprise shops.

With Integrated Security, you run your Tomcat service as a Active Directory Domain Account, then your credentials are remoted to SQL Server automatically. To get jTDS to work that way, you’ll want to make sure that you have place the DLL that ships with the driver in the right spot.

You’ll want to dump your jtds-1.2.5.jar file into <TOMCAT_HOME>/lib, but if you want to use Integrated Security, you’ll need to put that ntlmauth.dll file somewhere too. It has to be somewhere in your Windows path (we normally use Windows\system32), but you can happily put it into <TOMCAT_HOME>/bin and it seems to find it.

Word to the Wise: You need to match the right version of the DLL to your target operating system. I foolishly copied the 32bit version of the DLL onto a 64bit Windows install and wondered why I didn’t get a connection (nor did I get an error message that helped me out, so be warned).

Further Word to the Wise: We had to run the Tomcat service using the “@” format of domain account. So instead of “yourDomain\yourAccount”, we ran the service as “yourAccount@yourDomain”. Didn’t even know that worked! I’m such a MS noob these days..

Enough SQL Config. It’s time to have a look at AD integration.

Grails & Active Directory

Given that we’re using the amazing Spring Security plugin for Auth, it was a  no-brainer to head down the Spring Security LDAP plugin path and tune things for Active Directory. Our config is pretty vanilla per the sample docs, but we externalise it so we can tune it after deployment:

// Turn this switch on to enable Active Directory/LDAP Integration
grails.plugins.springsecurity.ldap.active = false

// LDAP config
// In particular, the Admin Account is only required to located the full DN of the user within the search base.
// Once that's found you can just bind as the real user.
grails.plugins.springsecurity.ldap.context.managerDn = 'CN=LdapSearchAccount,OU=My Users,DC=bytecode,DC=com,DC=au'
grails.plugins.springsecurity.ldap.context.managerPassword = 'yourClearTextPasswords'

// User-specific LDAP Configuration
grails.plugins.springsecurity.ldap.context.server = 'ldap://dir1.bytecode.com.au:389/'
grails.plugins.springsecurity.ldap.authorities.ignorePartialResultException = true // typically needed for Active Directory
grails.plugins.springsecurity.ldap.search.base = 'OU=My Users,DC=bytecode,DC=com,DC=au'
grails.plugins.springsecurity.ldap.search.filter="sAMAccountName={0}" // for Active Directory you need this
grails.plugins.springsecurity.ldap.search.searchSubtree = true
grails.plugins.springsecurity.ldap.auth.hideUserNotFoundExceptions = false

// Role-specific LDAP config
grails.plugins.springsecurity.ldap.useRememberMe = false
grails.plugins.springsecurity.ldap.authorities.retrieveGroupRoles = true
grails.plugins.springsecurity.ldap.authorities.groupSearchBase ='OU=My Groups,DC=bytecode,DC=com,DC=au'
grails.plugins.springsecurity.ldap.authorities.groupSearchFilter = 'member={0}'

Determining DNs

We found that getting the right DNs for Groups and Users was a bit of a pain. Lots of the samples use CNs for the different containers, but in the wild we have found that OUs rule the roost.  We found that Microsoft’s AD Explorer tool was a good way to work our the correct DN for the containers for users and groups (spaces in names seem to work fine too – yah!).

Our only snag was that cleartext manager password. I should get motivated and write a patch for that (following the same patterns as the encrypted datastore passwords).

We use AD-based ROLES for all our app-based security stuff. Creating groups in Active Directory called “GMARC_Admin” will result in the mapping becoming ROLE_GMARC_ADMIN once the user authenticates, which makes sense, so cater for that in your mapping. We ended up using DB-based security mapping rules so we can reconfigure the app’s security after deployment. Turns out that was a good decision!

What about Browser-based SSO?

We’ve been toying with the idea of a full SPNEGO/Kerberos SSO deal, but have yet to make that leap. For starters, our clients were happy enough to be able to login to our app using their username/passwords (this is going to be a problem down the track for agencies that use some kind of token-based logon, so we’ll probably go full-on Kerberos in our next major rev and deal with the browser-fallout when it happens!).

How’s it working out for you?

Once we’d shaken down the basic config problems, and come up with some diagnostic tools, we’ve been pretty happy with the result. SQL Server seems to perform pretty snappily. And Tomcat runs just great on Windows. Only only big hurdle left is a nice Windows-based installer. Sounds like a 1.1.x feature

Here’s my stab at the tech areas I’m interested in getting across in 2012:

• Grails 2.0 Deep Dive. Grails In Action has a completed TOC and a slated release schedule for 2nd Edition. So I guess most of the hard work is already done No doubt there will be many adventures posted here in the days to come.
• GUI Applications. I know everyone is giddy with mobile at the moment and I spent plenty of time building mobile apps for every possible device on a project last year. This year I’ve ended up with a couple of major Swing gigs on the timeline, so this is a great chance to catch up on Frankenstein GUI skills (for all platforms, not just Swing). Native Android might be a good experiment area here too. And Griffon goes without saying. It’s much harder when you don’t have a “Twitter Bootstrap” for Native GUIs!
• Integration Testing. I’ve flirted with Geb after Luke’s sessions at 2GX, and I’m also keen to explore more native Web-centric tools (like FuncUnit) to explore what kinds of tools are productive for me.  I went live with my first major piece of Grails Commercial Software late last year, but my biggest snags have been browser-specific issues! I’m hoping some functional testing will help.
• JBoss. Ok this one is definitely a little left of centre. But I live in a (mostly) Websphere town and I’m really tired of dealing with the insanity and wastefulness of that platform. I’d really love to have a full-stack alternative (SOA is big in Canberra) that I could offer clients as a migration strategy. I think JBoss is worth exploring here for that reason alone.
• MongoDB. Of all the NoSQL options, Mongo looks the most interesting to me. I own a couple of books, and the Grails support for NoSQL is pretty rocking right now. I think the trickiest part here is actually getting a feel for NoSQL Schema design in document stores. It’s not like there’s an easy “Third Normal Form” type refactoring to apply.

• Training Skills. A lot of the ideas in Pragmatic Thinking and Learning apply specifically to how to train and mentor people. I really want to experiment with this over the course of the year by running some experimental training sessions and see how people cope with alternate presentation/learning courseware. Should have a good impact on the book too!
• Leadership. I’m now serving on the leadership board of several for-profit and non-for-profit organisations. I bring plenty of technical horsepower, but don’t really contribute much in vision casting, strategic planning and people development. All my non-tech reading this year is going to be along the lines of “developing people” but in a Glen-kinda-way rather than just a John-Maxwell-regurgitate kinda way. Honestly there is so much junk written about leadership that is passed on unprocessed…But that’s for another <rant/>
• Minimalism. I’ve actually been applying a bunch of the ideas from “The Joy of Less” that I’ve found really helpful in building a much more conducive living and working space. Think of it as “Eliminate Waste” but applied to your whole life rather than just your code! Lots to learn here, and lots of habits to unlearn to.

Well that should keep me busy for a while…. At least for 2012…

First let’s review last year’s list:

• JavaScript – Yup! I can certainly tick this one off. Did several pieces of hardcore JavaScript work for clients (some without framework support), learned enough QUnit to be dangerous, and even did a bit of Backbone.js.
• Android/HTML5/CSS3 – Check. I’m bundling these together since I ended up doing a major PhoneGap project for a client this year. Had a chance to building a HTML5/CSS3 app for them on iPhone/iPad/Android/Blackberry/WinPhone7. If nothing else, I’m now pretty solid on CSS3 media queries and device toolkits!
• Grails Testing – Check (but lots more work to do). Spent a lot more time writing Spock tests this year and I’m definitely further along the road towards productivity here. Actually, the most useful TDD resource I came across this year was the PragProg screencasts of Kent Beck doing TDD. So practical and non-preachy. Really great. Went ahead and read the original TDD book and found that helpful too!
• Graphic Design. Well. I’ve discovered that I’m fighting city hall on this one. I’ve put too much energy into this for very little result. What I did discover this year was that I can happily customise templates to my cause (Twitter Bootstrap, anyone?) and it’s more productive to outsource the rest!

Also had  chance to do several Grails talks this year including a Grails Code Camp in New Zealand, SpringOne2GX in Chicago, and GR8Conf/OSDC in Canberra.

So what’s on the agenda for 2012? That’s the topic for the next post…

Interesting this is definitely one of the hardest core developer communities I have hung out with. Hardly any Macbooks/iPhones in sight and Linux laptops and Android phones everywhere! People are really committed to the Open Source way here.

The First Ever GR8 Conf in .au

It was great to hang out with a bunch of the awesome team from the local Groovy and Grails community. I gave a shortened version of my SpringOne talk on Grails UI refactors. The slides are up on SlideShare if you missed it:

After a fantastic day of talks from a bunch of great speakers, we had a  chance to kick back with Paul King, Steve Dalton, Craig Aspinall, Peter McNeil, Dean Macaulay, Paul Kilpatrick, James Swann and a bunch of CJUGers at the local watering hole.

Hacking PhoneGap for Fun and Profit

Earlier today I had great fun presenting to an enthusiastic crowd of mobile developers on the joy of PhoneGap. Again, the slides are on SlideShare.

One of the great facilities they had at the conference centre was an old-school data projector. We put it to good use showing off the deployment of our little conference app to my actual Android phone. Ever though a few of the demos snagged, it was all part of the fun of deploying to real devices!

Thanks to @spidie, @jamedmonson, and @davecode for the pics!

Had a fantastic time hanging out with everyone too! Great conference so far!

I’ll be giving a talk titled, “Fake Your Way as a Mobile Developer Rockstar with PhoneGap” where I’ll be talking a little about a recent client project I was working on developing for iPhone,iPad,Android (phone + tablet), Blackberry, Playbook and WinPhone7. It was a true “write once, test everywhere” experience!

Anyways, to show off a few of the key ideas, I spent a few hours yesterday morning whipping up a “Conference Schedule” app. The conf organisers kindly flicked me a schedule spreadsheet to use for the demo, which I prompted published as a Google Spreadsheet. All the data for the app is sourced from there, so Google Spreadsheets becomes my CMS for Schedule changes!

This session is going to be all about “faking it”, so while my graphic design skills are pretty rubbish, the amount you can get done using jQueryMobile, jQuery, Handlebars.js, PhoneGap and a few JavaScript libraries in a few hours is pretty sensational.

To do all the Google Spreadsheet parsing, I’m using a nice little library called Google-Spreadsheet-Javascript which has been perfect for the purpose of turning a spreadsheet into JSON! Based on the samples that come with the library (try one here), pulling data from a published spreadsheet is as simple as:

      var osdc_url = "https://spreadsheets.google.com/pub?key=0AsIKXTGzbbNtdDYwZGF3NGtFeVZCRGJDTzhLLTI1YWc&hl=en&output=html";
      var googleSpreadsheet = new GoogleSpreadsheet();
      googleSpreadsheet.url(osdc_url);
      googleSpreadsheet.load(function(result) {
    	  alert("Remote OSDC Schedule Sync'd");
    	  osdcData = result;
      });

The trickiest part was finding the “Publish to Web” option in the Google Spreadsheet itself (which is buried under the File menu rather than the normal Share menu). Now if only I can get Google Spreadsheets to present the dates in the right order I’ll be ready to roll…

See you there next week! (Oh, and all the source code for the app is up on Github).

First things First: Relationships trump everything

The absolute best part of these events is the chance to hang out with our awesome Groovy community making new friends and catching up with old ones. Just have a scan of the Wed night Groovy and Grails BOF (click picture for a closeup) to get a feel for how fantastic our community is (somewhere in this picture are heaps of the names you’ve run across Scott Davis, Graeme Rocher, Burt Beckwith, Guillaume Laforge, Dierk Koenig, Paul King, Colin Harringon, Bobby Warner, Dave Klein, Jim Shingler and many more). The audio will be up on grailspodcast.com shortly.

Friends Old and New

There’s nothing better than catching up with old friends from the Grails community: Andres, Dierk, Scott, Graeme, Jeff, James, Paul, Peter, Luke, Dave & Ken. And it was doubly wonderful to make a whole bunch new friends: Colin Harrington (Grails Testing Guru), Tim Berglund (of the Tim & Matt Git Video fame), Peter Niederwieser (Spock author), Andy Clement (STS Grails IDE support and Agent Reloading) and Jim Shingler (thanks for the insights on Grails in the large!).

And then there is seeing all the great guys from the community including Bob Rullo, Bryan, Jeff Gortatowsky, and too many others to name. So great to see you all!

Grails In Action, 2nd Edition

You asked for, and it’s happening! The most common question heard at the Manning SpringOne2GX desk this week was “Grails in Action, second edition. When?” Thanks so much for your interest (signed heaps of books over the week too!). If you’d like one on the cheap, head over to the Grails in Action page, and use code spring3911 for a 39% discount!

The good news is that Peter Ledbrook and I sat down the Mike Stephens from Manning and thrashed out a plan to get this bad boy up and running. Stay tuned for some MEAP annoucements early 2011. Peter has already started talking about NoSQL coverage, testing deepdive, resources and dependency resolution coverage and tons of other refreshed Grails 2.0 content. I feel tired already! Can’t wait to get started! (Drop us a line if you have specific things you want covered – now is the time to get your requests in!)

Core Inspirations: where to from here?

In case you were interested in the topics covered from the sessions I went to, here are the things on my todo list after 2GX:

• Geb and Functional Specs (Luke session got me thinking here)
• Next Level Spock (Peter Niederwieser is such a champion – and sounds *exactly* like Arnie)
• Taking the Grails Testing movement forward (Colin Harrington really charged me up for this)
• NoSQL perspectives (Graeme’s session on Grails NoSQL was awesome! Super excited about this)
• Coffeescript & Node (not sold on this one, but Scott has persuaded me to at least have a look at Node)

Glen’s Sessions

The 90 minute session format makes it really hard to maintain audience interest, but fortunately I had fantastic people in my session! I ran two sessions, one on refactoring the Grails view tier titled “Does my DIV look big in this?” (lots of Charlie Sheen references lead to a spate of #winning and #tigerblood tweets – it was such a fun crowd we had a ball).

For my second session, I put together a talk titled “Grails Hacker Triage: 10 Grails code smells and refactors” (crowd shown below). This talk was a little experimental and I had quite a few snags pulling it off, but again the crowd were really understanding and had great ideas for improvement next time. Thanks team! I’m going to turn this talk into 10 blog posts over the next month, so stay tuned to dump some “better practices” ideas on me.

So In Summary

This was one of best Grails events I’ve ever been to (so glad I skipped J1 this year to make it!). If you have a chance to get there next year, make sure you do. Great people and Groovy/Grails content made for some fantastic discussions and hangouts. Recommended!

• Grails Resources (for shrinking your dependencies)
• Various Grails and non-Grails DRY view technologies (including bean-fields, navigation, validation and other jQuery related goodness)
• Less.css for keeping your CSS nice and DRY
• Twitter Bootstrap (for gridding and standardised layouts)
• Backbone.js for giving some rigor to my JavaScript views (and painless REST sync)

If any of those technologies are on your radar, make sure you come along! I’m really keen to hear your views on what has worked for you and how we can move towards more low friction Grails views.

We’ll be taking a noisy and loveless default UI:

And giving it a solid makeover for markup, layout and behaviour:

It’s gonna be a blast! See you in Chicago!

Caused by GrailsTagException: Error executing tag <bean:form>: Cannot get property 'class' on null object

You know you’ve tripped the issue.

I’ve logged the issue in GPBEANFIELDS-40 but the root cause is actually not beanfields at all. It’s a breaking change introduced in Grails 2.0.0-M2 for performance improvements (GRAILS-8001). The change has since been made backward compatible for RC1, so the break only occurs on 2.0.0-M2.

Line 922 of BeanFieldsTagLib needs a mod… Comment it out and replace with the mod below

//attrs._BEAN.bean = attrs.remove('bean') ?: pageScope.variables[attrs._BEAN.beanName]
attrs._BEAN.bean = attrs.remove('bean') ?: pageScope.getVariable(attrs._BEAN.beanName)

And you’re in business!

Remember, this ONLY applies to 2.0.0-M2, all will be well in RC1!

Enjoy those DRY forms… And go buy Marc Palmer a nice wine next time you’re in the UK. I plan on it.