Thursday 12 November 2009

Learning Closure. Ajax with goog.net.*

This blog is moving to caprazzi.net.

Google released closure library, a javascript library good to make rich internet applications.

As this is going to be an important library in software developement, I decided to try it. 'Ajax' networking is a good starting point, so I looked into the package goog.net and found two promising classes, HxrIo and XhrManager, which I used for my tests.

The documentation is clear but sometimes shy about who does what. Fortunately there are plenty of links to the source code, which is well written and documented.

The interesting code is below, but there's a more extend version of my closure-library tests.

Just hit a url without waiting for a response

// load the modules
goog.require('goog.net.XhrIo');
goog.require('goog.Uri');

// the easy way: static function call with no callback
goog.net.XhrIo.send('url/');

// using the send() method of an instance.
new goog.net.XhrIo().send('urlA'); // GET, default
new goog.net.XhrIo().send('urlB', 'POST');

// also works with an Uri object
var uri = new goog.Uri('urlC');
new goog.net.XhrIo().send(uri, 'PUT');

// no http method validation, this is a valid call
new goog.net.XhrIo().send('urlF', 'XXXX');

// send some data with the POST, works as expected
new goog.net.XhrIo().send('urlG', 'POST', 'p1=v1&p2=v2);

// ATTENTION data will not be attached to a GET
// so this call won't do what you may expect.
new goog.net.XhrIo().send('urlH', 'GET', 'p1=v1&p2=v2');

Request data from the server

// an html file as text
goog.net.XhrIo.send('sample.html', function(event) {
 var text = event.target.getResponseText());
});

// an xml file as document object
goog.net.XhrIo.send('sample.xml', function(event) {
 var document = event.target.getResponseXml());
});

// a json file as javascript object
goog.net.XhrIo.send('sample.json.js', function(event) {
 var data = event.target.getResponseJson());
});

// spot the 404
goog.net.XhrIo.send('gone_fishin', function(event) {
 var success = event.target.isSuccess()); // false
 var status = event.target.getStatus()); // 404
 var statusText = event.target.getStatusText()); // not found
});

// !!! exceptions in the callback are swallowed, so check your conditions
// (there is interesting error handling stuff in goog.debug.*)
goog.net.XhrIo.send('gone_fishin.js', function(event) {
 // I expected some data, but the file is not there
 // and this will raise an exception...
 var data = event.target.getResponseJson();
 var field_data = data.field;
 // ...so this statement will not execute...
 alert('bonk');
 // ...BUT you won't see anything in your console.
});

// a 404 using an XhrIO instance and closure event management;
var io = new goog.net.XhrIo();
goog.events.listen(io, goog.net.EventType.COMPLETE, function(event) {
 var status = event.target.getStatus()); // 404
});
io.send('gone_fishin');
Using the connection manager

goog.require('goog.net.XhrManager');

// goog.net.XhrManager(opt_maxRetries, opt_headers, opt_minCount, opt_maxCount, opt_timeoutInterval)
var mgr = new goog.net.XhrManager(2, null, 0, 2);
goog.events.listen(mgr, goog.net.EventType.COMPLETE, function(event) {
 // this is fired once for each send(), even if they are retried
 var xhr = event.xhrIo;
});
mgr.send('id_one','closure.js');
mgr.send('id_two','/urlTwo');
mgr.send('id_three','/urlThree');
mgr.send('id_four','/urlFour');

// reusing an id before the request is complete, causes an exception...
try { mgr.send('id_one','/x'); }
catch (e) { /*[goog.net.XhrManager] ID in use*/ }

// ...unless the connection is aborted
mgr.abort('id_one');
mgr.send('id_one','/x');

mgr.send('other_id','/someurl', null, null, null, function(event) {
 // it's ok to reuse an id an after the request completed
 mgr.send('other_id', '/fool');
});

This blog is moving to caprazzi.net.

Friday 23 October 2009

book: forms that work

Forms that Work: Designing Web Forms for Usability

There is no html in this book, it's not about programming forms. And that's why I liked it.

This short book clarifies what good form design is about, in plain english. Plenty of images help, too.
I'm still not too good at designing forms but at least now I know the name of the game.

-teo




 

Thursday 15 October 2009

book: don't make me think

Don't Make Me Think!: A Common Sense Approach to Web Usability




Delightful one-night read. Some good common sense advice on web design and two brilliant chapters on usability testing on a budget.

common sense is underrated




Thursday 8 October 2009

netflix prize contest, a new one


With netflix announcing a new contest, it's time to look back at how the Netflix Prize ended: BellKor's Pragmatic Chaos team (AT&T Research engineers) won over the ensemble (a creek of lower-ranked contestants), just minutes before the deadline.

Both teams blended together different algorithms to improve by 10% the hit rate of existing netflix suggestion engine.

This is a story of monkeys and challenges, interesting beyond bytes and keyboards. Wired has good coverage, but you can google for more.

I'm reading Programming Collective Intelligence, which so far is ranking high: it uses easy-to-read-and-write python to build suggestion engines using many different algorithms. For programmers.

story coverage:

related papers:



Monday 3 August 2009

Above the Clouds: The View from Berkeley

RAD Lab released Above the Clouds: The View from Berkeley (pdf) an high-level overview of the cloud. It's great read for anyone interested in the subject, no need to be involved in software development.

It's the best text on the subject that I've read so far: the authors start and stay above the cloud, avoid stepping on technical traps, yet they never become too theoretical.

The paper will tell you what the cloud is and what is not, how it fits in today's IT ecology. It also describes the "economics of the cloud" with no-nonsense formulas and pragmatic statements, making sensible assumptions and predictions.

If anything, I think it underestimates the impact of private clouds for small and medium organizations in the future. Designing your data center as cloud buys you a greater potential for scalability and flexibility.

Add that even a tiny company benefits from exposing its data layer as a service with domain specific logic (that is, a SaaS with an API), and that couples perfectly with a cloud architecture.

This is straightforward only for new organizations; a massive paradgim switch in an existing company could well kill it...

Friday 3 October 2008

Falickaway: a flickr viewer

Available now: flickaway (demo)

I love flickr.

I also love my pictures, and sometimes flickr feels too... generic? impersonal?
Anyway. I decided to spend some time coding this flickr viewer so to have a website with my style and the same pictures I have on flickr.

I thought someone else might find it useful. If you like it, just go there, run the wizard, copy the generated html in an html file. Deploy to a web server. done.
Yes, the wizard is javascript-only as well.

I almost forgot: that html page is less than 2k.
All the javascript and the styles will be fetched from my website (or google, or yahoo), so you'll always get the newest and best version.

A brief on technology:
I'm using jQuery (from googleapis.com), google feed apis and flickr rest api (on the wizard, to discover your feeds). All files are gzipped then deployed on Amazon S3.

Matteo

Monday 8 September 2008

[C Testing] MinUnit - less is more

- Can a whole framework be 3 lines long? -

The C project I'm working on is quite small in LOC and files. It won't grow much as it's deployed on a chip with 4k program space and 256 bytes of ram.

No matter how small, test all your code. Always. Period.

Problem is, where to start?

Approaching unit testing may go down two different paths.

Write few functions with ifs and printfs, call them from a main(), execute and see. It's prone to code duplication and you'll soon start reinventing the wheel. You are paving your way to a maintainability hell. Anyway, It might work for small projects and is very easy to get started with. 

Otherwise you can embrace a framework such as CppUnit o Check, learn it and start writing tests. You get more power and less duplication. You'll benefit from standardization, automation and much more. It's the best approach, except for the steep learning curve. Add that writing tests is not exciting nor easy, and you might end up being so frustrated that you'll never get your test suite done. 

Introducing the solution: MinUnit, a unit testing framework in 3 lines of code (!!!!):

/* file: minunit.h */
#define mu_assert(message, test) do { if (!(test)) return message; } while (0)
#define mu_run_test(test) do { char *message = test(); tests_run++; \
) extern int tests_run;
if (message) return message; } while (
0

(This kind of magic is why I really do miss macros in Java)

At least it is the solution for my small-scale project.

Just copy those few lines in a header file, include it and start writing tests. It is really that easy. And gone is your excuse for not testing. 

Really, this might be all you need even for a mid-sized project. Especially if you are introducing unit testing in an existing project, the jump start can really pay off.

One important feature of (some) bigger frameworks is that the test runner executes your test code in a separate address space. This way if your buggy code picks the wrong pointer, it won't bring down the test runner, but only that unit. The runner will report it as a failure and move on. Do that with MinUnit and probably you'll have no clue of what hit you.

Make no excuses, test-your-code.

For the records, I modified it a little bit, adding a specialized assert:
#define mu_assert_eq(expected, actual) {\
int a = (expected); \
int b = (actual); \
do { if ((a) != (b)) { \
sprintf(minunit_msg, "FAILURE %s:%d expected %d, got %u", __FILE__, __LINE__, a, b);\
return minunit_msg; }; \
} while(0); }

There is a complete example on the project page or have a look at a real world example: test_ring_buffer.h and test.c

Matteo