Invisible to the eye

Weekly roundup: the coming war

2012-01-15T12:59:00.001+01:00

Now, it may seem like SOPA is the end game in a long fight over copyright, and the Internet, and it may seem like if we defeat SOPA, we'll be well on our way to securing the freedom of PCs and networks. But as I said at the beginning of this talk, this isn't about copyright, because the copyright wars are just the 0.9 beta version of the long coming war on computation. -- Cory Doctorow

I advise you to read the full transcript of Cory Doctorow's talk (or watch the video) The Coming War on General Purpose Computation to get a feel of where the closed&special purpose devices trend may head (or is already heading) in the future. Sacrificing Turing-completeness is something no engineer can dream for.

Here are my articles published this week on DZone.
Practical PHP Refactoring: Push Down Field explains how to move a field down into a class hierarchy to simplify the involved superclasses.
Object-oriented Clojure is a tutorial on how to use Java objects from Clojure and how to define new interfaces and classes (actually protocols and records).
Practical PHP Refactoring: Extract Subclass explains how to extract a new subclass, something we assumed already existed in the previous articles of the series.
Open/Closed Principle on real world code is an implementation of the Command pattern in PHPUnit_Selenium, displaying production code instead of the usual self-contained examples.

Weekly roundup: Wirfs-Brock's book

2012-01-08T12:49:00.004+01:00

I have started reading Rebecca Wirfs-Brock's 2003 book, cited by XPers as one of the books that teach the lost art of object-oriented design. So far I have filled one page of notes while reading the first chapter, and reached the first code sample on Double Dispatch; it's a very dense book.
It's too soon to tell if this book's content is obvious or mind-blowing - but it can succeed in instilling a design mindset different from the modern OOP one; for example, based on roles and responsibilities instead of "records with functions attached to their heads".

These are my articles published this week on DZone.
Practical PHP Refactoring: Pull Up Constructor Body completes the miniseries on pulling up duplication into a superclass, as one of the ways to eliminate it.
TDD for multithreaded applications is my attempt at test-drive the design of a distributed applications without resorting to sleep() calls and non-deterministic tests.
Practical PHP Refactoring: Push Down Method is one of two articles on simplifying superclasses by pushing down pieces of code that are specific to a subclass.
Web application in Clojure: the starting point is an howto for using Ring, the equivalent of the Servlet API in the Clojure world. I probably will try out higher-level tools in the next weeks, like Compojure or Noir.

Biweekly roundup: waterfall resolutions

2012-01-01T14:08:00.001+01:00

No new year's resolution for me; I've come to think they have the trait of a waterfall process: what if you realize the established goal is revelaed to be not so good for you? Even with "universally" recognized beneficial habits, you may discover they're not so important after a change in priorities. Exercising every day may be superceeded by practising a sport; learning a new programming language may be by a new job where you specialize in a single one. To me, it sounds waterfall-ish to establish an yearly goal and work towards it without revising the situation at least monthly.

By the way, in the last two weeks of the year I have published a few articles on DZone that may interest you.
Practical PHP Refactoring: Replace Error Code with Exception explains how to write object-oriented PHP also in dealing with errors.
The Spark micro framework is a concise, self-contained framework for quickly develop Java web applications.
Practical PHP Refactoring: Replace Exception with Test attempts to avoid unnecessary exceptions when an error condition can be early detected.
3D experience in a browser with Three.js is a review of a library for building 3D scenes in a browser over WebGL, the canvas element or SVG.
Practical PHP Refactoring: Pull Up Field explains how to eliminate the duplication of a field within an inheritance hierarchy.
Clojure libraries and builds with Leiningen explains how to pull Clojure and Java libraries and compile with them from the command line, like you could do with Ant and Maven.
Practical PHP Refactoring: Pull Up Method explains the use of inheritance to eliminate the duplication of a method.
Open source PHP projects of 2011 is a non-scientific review of the most popular and exciting projects in the PHP landscape.

Biweekly roundup: more and more languages

2011-12-18T12:54:00.001+01:00

I am a PHP developer and a student by day, but I don't want to limit my options: I'm currently experimenting with Clojure and exercising with Rails. Each new language or platform teach us something general about programming; I advise you to abandon any prejudice if you decide to dive into a new language in your practice time (which for a PHPer programming Ruby is essential.)

Here are my articles published in the last two weeks.

What I learned in the Global Day of Code Retreat is a summary of my experience at the Code Retreat in Milan during the Decembed edition.
Practical PHP Refactoring: Remove Setting Method is about guaranteeing immutability or simplifying the interface of an object by throwing away a method.
Testing and specifying JavaScript code with Jasmine is an example of usage of the popular BDD JavaScript testing framework.
Practical PHP Refactoring: Hide Method is about information hiding: limiting the scope of a method to be able to easily evolve it later.
Practical PHP Refactoring: Replace Constructor with Factory Method transforms a giant constructor into several well-named Factory Methods.
Rails from the point of view of a PHP developer is about me trying out Rails 3 (again, without prejudices).
Practical PHP Refactoring: Encapsulate Downcast (and Wrapping) is about the PHP version of downcasting: converting primitives and wrapping them in Value Objects.
jQuery plugins with jsTestDriver is an example of real world JavaScript development with TDD.

Weekly roundup: the code retreat

2011-12-04T19:22:00.001+01:00

Yesterday was the Global Day of Code Retreat, an event where local groups of developers get together to hone their skills. It consists of six iterations of solving a problem (simulating the Game of Life) in pairs, where at the end of each hour the code is deleted and the pairs mixed. This combination enforces a focus on the method, not on the result; and allows to try out many different approaches (outside in, bottom up, functional and object-oriented languages, using no else or primitive types, closed eyes and an hand tied behind your back...)

I will write more about the experience in Milan in the next days on DZone. Here are my articles published in the past week.
Practical PHP Refactoring: Replace Parameter with Method is about simplifying a method's argument list by eliminating premature parameterization.
Clojure for dummies: a kata is the FizzBuzz problem implemented in Clojure, a now-popular Lisp dialect.
Practical PHP Refactoring: Introduce Parameter Object is about replacing a list of parameters with a single object.
HTML5 Drag and Drop uploading outlines how this technique works, when it breaks and how you can get it in your application in a few minutes.

XPUG Milano, November 30th

2011-12-01T18:05:00.001+01:00

Yesterday Uberto Barbini held the second part of his Agile Day presentation at the eXtreme Programming user group in Milan. Here are the topics of the talk and the discussion, that you can also follow on the slide deck.

At the conference (video in Italian), Uberto covered only part of the presentation, so he restarted from the half presentation check:

many bugs are caused by shared, inconsistene state
the procedural paradigm doesn't care how you organize state
OOP encapsulates state inside objects
functional programming expels state from pure functions.

An example of OOP went wrong was a MyBag object which allows read and write access to any item inside. The Singleton pattern used for no reason and the absence of any form of Dependency Injection are other common pitfalls: just because a piece of code contains many classes and methods it does not mean it is object-oriented.

The Blackboard

An interesting thing came up while this non-OO code was presented to us: we cannot judge a design without knowing which is the underlying problem it solves. While changing class names simplifies a slide, the same Blackboard metaphor can be implemented with wildly different results:

in the case of a list of actions to perform, it couples the actions in a certain order; the first or second action populates the blackboard for the other ones and cannot be moved.
in a distributed scenario, it decouples different processes from knowing the rest of the system, and allows new configurations.

Yet the scenarios are identical if not for the names of classes and methods.

The presentation went on to compare the object-oriented and functional approach as different tools for solving different problems: they are not always in competition, but code can contain a mix of both according to the problem at hand. For example, Uberto cited simulations as a really natural place for objects, and transformations of data into different formats (XML, JSON) as a call for pure functions.

This reminded me of the Expression Problem and of how new requirements favor either the functional or object-oriented solution.

Rebecca's book

I'm not sure I will understand the Centralized/Dispersed/Delegate control comparisons before reading Rebecca Wirfs-Brock's book on design, but an issue that came up is that this kind of books is disappearing, despite being very handy in teaching design. Today we see many technical books which teach how to code in Java or Clojure or Ruby, but not book on how to model and solve problems with code.

Elegance and familiarity

A final note is Rick Hickey's (inventor of Clojure) quotation:

Elegance and familiarity are orthogonal.

Just because we see functional code as strange and different from the object-oriented approach, it does not mean it's inelegant: probably just that we are not familiar with it. It is closed against different changes than the equivalent OO solution; and a functional programmer will see our objects as inelegant too.

PHPUnit_Selenium 1.1.1 has been released

2011-12-01T17:31:00.001+01:00

Yesterday Sebastian reviewed my PHPUnit_Selenium master branch and release a new package in the phpunit PEAR channel. You can install it along with PHPUnit easily:

$ sudo pear install phpunit/PHPUnit_Selenium

Before this release, PHPUnit_Selenium was broken when used with PHPUnit 3.6.

I'm closing several more issues and I plan to cover with tests the 2K lines of code contained in the package: currently the test coverage is terrible. After the current features are covered, we can start thinking about supporting the Selenium 2 API (based on WebDriver). In any case, I will keep backward compatibility: support for WebDriver will come with another base Testcase Class.
If you want to contribute, consider providing tests for the functionality you are using. For example, the following areas are uncovered:

running Selenese tests
all the Custom Assertion methods
running tests in multiple browsers.

Acceptable tests comprehend an HTML page to use as a target and the actual test, written in Selenese or using PHPUnit_SeleniumTestCase. If you want your pull request to be immediately accepted, provide a test along with the rest of the code. You can take some inspiration from the existing ones in the Tests folder, which will serve as examples.

There is an undocumented, experimental feature in this release: call PHPUnit_Extensions_SeleniumTestCase::shareSession(true) in your bootstrap and the browser session will be shared between tests; a new session will be restarted only after non successful tests.
It will be up to you to reset the state of the browser to perform new tests, and will leave the browser windows open after the end of the run: it's called experimental for a reason.

Weekly roundup: PHPUnit_Selenium

2011-11-27T15:40:00.001+01:00

I am now the maintainer of PHPUnit_Selenium, the PHP library for writing PHPUnit test cases that make use of Selenium RC to drive a real browser (usually to perform end-to-end tests). PHPUnit will continue shipping the library, and PHPUnit_Extensions_SeleniumTestCase will continue to be compatible with the Api in the manual.
Right now, you should use PHPUnit_Selenium in tandem with Selenium 2. Selenium 2 integrates WebDriver (not supported yet from PHP code) and implements the old Selenium RC Api, so it will continue to work and be maintained. If you encounter a backward compatibility break, open an issue.
PHPUnit_Selenium was not maintained and was broken in PHPUnit 3.6; with the next release, it will resume working. I'm integrating all sort of pull requests initiated during 2011, so if you want to contribute or to merge back one of your forks, you will be welcome!

Here are my original articles published this week.
Practical PHP Refactoring: Replace Parameter with Explicit Methods explains how to break up a method into a few, finer-grained ones.
Setting up a LAMP box with Puppet is an how to on writing Puppet manifests for provisioning packages and services like Apache, PHP and MySql in a machine (instead of writing long scripts containing apt-get, yum and /etc/init.d/ calls).
Practical PHP Refactoring: Preserve Whole Object explains how to pass an entire object to a method instead of extracting its state and passing a series of variables.
PhoneGap: native applications written in HTML is a review of a mobile application frameworks which promises to wrap your Ajax-based applications into an Android or iOS one.

Weekly roundup: Italian Agile Day

2011-11-20T14:13:00.001+01:00

Yesterday I followed via streaming the 8th edition of the Italian Agile Day, since I was unable to go to Rome for the event. If you speak Italian, stay tuned as many talks have been recorded and will be published (the event does not seek profit.)
Of course I missed the networking dimension of such a big event, but at least I enjoyed some talks on methodology while I am mostly a technical person. Look for the bottleneck!

Here are my original articles published this week on DZone.
Practical PHP Refactoring: Separate Query from Modifier is about respecting the Command/Query Separation principle.
Selenium 2 from PHP code explains which options you have right now for accessing the Selenium 2 (WebDriver) Api from a PHP script.
Practical PHP Refactoring: Parameterize Method explains how to unify different versions of a method in a single one with more parameters.
Creating a virtual server with Vagrant: a practical walkthrough is an howto for making Vagrant build a virtual machine with your OS and software of choice, instead of creating that machine and go through the installation process of an .iso image yourself.

Weekly roundup: universal software development rules

2011-11-13T12:59:00.001+01:00

This week, Kevin Schroeder from Zend collected responses to his tweet asking what are the universal software development rules. My take, cited there, is that there not many universal practices that you can follow. There are many conflicting metrics to measure the quality of a software piece, and their relative importance depends on the domain in which we are in.
For example, in development of embedded systems (which do not even run on general purpose microprocessors), many "clean code" practices like Don't Repeat Yourself and Keep It Simple Stupid are subverted. We may replicate the code for an operation to parallelize it and lower the response time of the system; we may micro-optimize operators and substitute multiplications with binary shifts. Power, energy and cost of a circuit come into play more than expressiveness of the code...

These are my original articles published this week on DZone.
Practical PHP Refactoring: Add Parameter is about adding an explicit parameter to a method instead of trying to look it up in a singleton or in some other place by itself.
Eventual consistency is everywhere in the real world contains a few examples of how eventual consistency (popularized in the programming world by NoSQL solutions) make many businesses work.
Practical PHP Refactoring: Remove Parameter is about simplifying a method by removing a parameter which is not needed anymore.
Web applications with the Play framework is a primer for the usage of a clean alternative to bloated enterprise Java stacks. And it supports Scala, too.

Weekly roundup: a short Pomodoro presentation

2011-11-06T13:15:00.002+01:00

Here is my Pomodoro Technique short presentation held at phpDay 2011 in Verona. It's not the same as the full one at PHP Barcelona, but it contains some frequently asked questions about Pomodoros along with some handy tricks.
Remember that English is not my native language. :)

Giorgio Sironi - An year of pomodoros - phpday2011 from GrUSP on Vimeo.

Here are also my original articles published this week on DZone.
Practical PHP Refactoring: Introduce Assertion is about the ancient usage of assertions, when they were embedded in production code instead of being segregated in an external test suite.
PHP on a Java application server is our experience with Quercus for running a PHP application on Resin. TL;DR: not really working.
Practical PHP Refactoring: Rename Method is about making method calls easier to follow: when a method's name is really explanatory you don't have to read into its body to understand what it does.
Using a virtual machine to play with multiple versions of PHP is a tutorial on setting up a VirtualBox machine with PHP 5.4 (the newest unstable version).

Weekly roundup: the Pomodoro Technique in Barcelona

2011-10-30T16:15:00.001+01:00

Here are the slides of my talk The Pomodoro Technique at PHP Barcelona last Friday. If you have found it interesting, remember to rate the talk on joind.in. I'd like to thank all the staff (who also gave away a Pomodoro Technique Illustrated book) and the audience, which was very interested and involved in the topic.

The Pomodoro Technique on Prezi

Here are my original articles that I published this week before the conference.

Practical PHP Refactoring: Replace Conditional with Polymorphism is the cornerstore of the elimination of conditionals.
Getting started with Selenium 2 is a primer for the usage of WebDriver, only with the official Java bindings for now.
Practical PHP Refactoring: Introduce Null Object explains the creation of an object dedicated to special cases.

I've had enough of running Scala in a terminal, let's try with a web application is the first step in my quest to develop for the web in Scala.

Weekly roundup: going to Barcelona

2011-10-23T18:38:00.002+02:00

I'm leaving for Barcelona on Thursday afternoon for the PHP Barcelona 2011 conference and I will hold my talk on the Pomodoro Technique on Friday morning. Feel free to ping me if you will be there, I like to discuss about the themes treated in my writings. :)

These are my original articles published this week on DZone.
Practical PHP Refactoring: Remove Control Flag is about refactoring from a boolean variable to statements like break and continue.
A look at Dart from the eyes of an OO programmer is my opinion on Dart.
Practical PHP Refactoring: Replace Nested Conditionals with Guard Clauses explains how to simplify a complex conditional before starting to extract objects.
Tell, Don't Ask in the case of a web service is a practical case of changing a design from a getter-based style to a Tell Don't Ask one.

Weekly roundup: hardware design vs. Continuous Integration

2011-10-16T11:23:00.001+02:00

I'm taking a course in ubiquitous computing where we are studying hardware design. It's interesting how a common methodology reminds me of waterfall - each phase from the behavioral specification to the logical synthesis (where you decide how many and, or and not to use) contains a thorough verification step.
The reason is simple - the last phase, the actual production of a custom integrated circuit is very costly (hundreds of thousands of Euros). So iterating a design including this phase is not possible at all.
In software, it's a bit different. We can afford a dedicated server that builds our application dozens of time each day.

Here are my original articles published this week on DZone.
Practical PHP Refactoring: Consolidate Conditional Expression is about extracting code from conditionals and applying polymorphism when possible.
What I have learned at DDD Day is about my experience at a conference on enterprise software, mostly oriented to .NET.
Practical PHP Refactoring: Consolidate Duplicate Conditional Fragments is about avoiding duplication even in ifs.
OAuth in headless applications explains how to access Facebook, LinkedIn and other Apis when the user can't continuously authorize your application.

DDD Day slides

2011-10-11T10:50:00.000+02:00

Here are my slides (if you can call them slides) for the DDD Day of Saturday in Bologna. The audio+slides playback will be available in the next weeks.
Note that the talk was oriented to an audience who knows what Domain-Driven Design is, but hasn't really worked with PHP yet (Java and C# developers).

DDD in PHP on Prezi

Weekly roundup: DDD Day

2011-10-09T16:57:00.000+02:00

From this photo, you almost cannot see that I was rasmussed by Greg Young

I've returned from the DDD Day, the Italian conference on Domain-Driven Design. I learned some concrete tips ad techniques in spite of the event being oriented to .NET and frequented by C# and Java programmers.
In fact, as Alberto Brandolini said in the morning, DDD is also about the method, not really about the technology; and the differences in technology between imperative object-oriented languages such as C# and PHP are not so high.

Here are my original articles published this week on DZone.
Practical PHP Refactoring: Replace Subclass with Fields is about the inverse move of refactoring from type codes.
The Goal of software development is an exposition of Goldratt's work applied to software development.
Practical PHP Refactoring: Decompose Conditional is the first article about dealing with ifs and possibly targeting polymorphism.
Temporal correlation in Git repositories contains the code for discovering which classes usually change together in the history of your codebase.

Bi-weekly roundup: DDD in PHP

2011-10-02T11:15:00.001+02:00

I'm wrapping up my presentation for the DDD Day in Bologna and beginning rehearsals. Since I am involved in the project as a software architect, I will talk mostly about the technical side (it's DDD in PHP, not DDD in transportation and rental companies.) Wit respect to Java and C#, we will take a look at the differences in the language, in the platform where they are run and in the Domain Model.
See you in Bologna on October 8th.

Here are my original articles published in the last two weeks.
First week
Practical PHP Refactoring: Replace Record with Data Class is about substituting data structures provided by the language or libraries with an object coded on your own.
Practical Google+ Api is a guide to get you up and running in coding for an application using Google+ as a data source.
Practical PHP Refactoring: Replace Type Code with Class is about substituting a field value with a new object.
Phar: PHP libraries included with a single file is self-explanatory: Phar is the equivalent of Jar for the PHP world.
Second week
Practical PHP Refactoring: Replace Type Code with Subclasses expands on the type code miniseries, by adding subclasses to the one containing the problematic field.
Cross-Site Request Forgery explained is my take on this security issue, providing three ways documented in the literature to avoid it.
Practical PHP Refactoring: Replace Type Code with State or Strategy is the third option for eliminating a type code: transforming its values in a hierarchy of State objects.
Pretotyping: a complete example describes my experience with Who Disagrees With Me? and all the data I collected, which suggests a very focused audience but a descending trend.

Who disagrees with me? Fourth and final issue

2011-09-23T15:29:00.001+02:00

I've just sent the fourth edition of the Who disagrees with me? newsletter, a pretotype for an aggregator of challenging links aimed to burst the filter bubble and confirmation bias. If that sounds obscure, consider as an example picking a PHP programmer like me and showing him where Ruby (or Java, or JavaScript) beats its preferred language. Ignoring the fact does not make the PHP programmer any better...
With this fourth edition I conclude the experiment of the newsletter and start thinking about a web application; I will take a look at analytics and subscriptions/unsubscriptions to see what has been the level of interest in the last weeks to see if the idea can be pursue further.
Please your opinions and criticism about Who disagrees with me? and these four issues in the comments.

Weekly roundup: speaking at DDD Day

2011-09-18T14:47:00.001+02:00

On October 8th I will speak at DDD Day in Bologna, an Italian event for Domain-Driven Design practitioners. The topic of the talk is DDD in PHP: which part of the approach changes with the programming language and platform, and which stay the same.
The abstract (in Italian, as for the talk) follows.

Cosa cambia nell'applicare Domain-Driven Design quando si passa da un linguaggio fortemente tipato e compilato come C# o Java ad uno dinamico e interpretato come PHP? Ci sono differenze ancora più subdole: il tempo di residenza degli oggetti in memoria è molto diverso, così come il livello di sviluppo degli ORM; per non parlare della differenza di mentalità fra gli sviluppatori, abituati a siti pubblici invece che a domini (applicativi) aziendali. Passare ad un linguaggio veramente diverso ci fa capire quali sono le parti di DDD che importano solo dal punto di vista tecnico (che quindi possiamo trascurare), e quali sono invece i concetti che non cambiano mai.

Here are also the links to my articles published this week on DZone.
Practical PHP Refactoring: Encapsulate Field
Backbone.js: MVC in JavaScript
Practical PHP Refactoring: Encapsulate Collection
Web typography in 2011

Who disagrees with me? Third issue

2011-09-16T13:29:00.003+02:00

I've just sent to subscribers the third issue of Who disagrees with me?, the newsletter providing a weekly article guaranteed to challenge the assumptions of your preferred programming language. There are still 5 different editions - PHP, Ruby, C/C++, Java and JavaScript.
Last week I got a feedback on Google+ about subscribing to multiple Preferred technologies. It would definitely be handy, but I can't change the setting now without losing the data from already subscribing people. It's something to keep in mind in case this becomes something more than a newsletter.
Who disagrees with me subscription

Weekly roundup: ergonomics

2011-09-11T19:36:00.005+02:00

I've been using a mouse not at the same height as my keyboard for years: it took different pains and a transition to Vim (where the mouse is useless) to realize that the ergonomics of my main workstation was not excellent.
OSHA (I trust the US government on these issues more than the Chinese one) has a checklist for checking your own work desk, along with links to further explanations and pictures of good and bad setups.

While you're checking and avoiding a Carpal Tunnel Syndrome, take also a look at my original articles published this week on DZone.
Practical PHP Refactoring: Change Bidirectional Association to Unidirectional
All the Git hooks you need
Practical PHP Refactoring: Replace Magic Number with Symbolic Constant
Future JavaScript, today: Google's Traceur

Who disagrees with me? Second issue

2011-09-09T14:51:00.000+02:00

I've just sent to subscribers the second issue of Who disagrees with me?, the newsletter providing a weekly article guaranteed to challenge the assumptions of your preferred programming language.
After two weeks and a half from the launch of the pretotype, the newsletter has grown to 5 of the 6 technologies available: there is a C, Java, JavaScript, PHP and Ruby edition.
I plan to prepare two more issues for the coming weeks before wrapping up the experiment. The result would be either the start of a new website or the end of the service, depending on user response (that's you!).
Who disagrees with me subscription

Automatically assign constructor parameters to private properties

2011-09-06T13:07:00.000+02:00

In Scala, a JVM language, constructor parameters become private fields of the class, by default:

class Person(age:Int) {
  def grow() = {
    age += 1
  }
}

I find it handy, as I always use private properties which are the target of dependency injection, in particular constructor injection.
Here's how to emulate this functionality in PHP, with great hacks. I post this code here so it won't be lost in the interwebs.

Weekly roundup: speaking at PBC 2011

2011-09-04T16:06:00.000+02:00

There is no official schedule yet, but speakers are beginning to confirm their presence to PHP Barcelona 2011. I will be there, with my talk on the Pomodoro Technique, a time management tool inspired by eXtreme Programming/Agile methodologies and widely diffused also outside of the software development field.
I also have seen confirming Juozas Kaziukenas, Stephan Hochdörfer, and Marcelo Duarte from iBuildings. See you all in October in Barcelona!

Meanwhile, here are my original articles published this week on DZone.
Practical PHP Refactoring: Duplicate Observed Data is a refactoring associated with moving fields from the presentation layer to the domain one, in the cases where their values take part to the execution of some logic, like validation or a change in state.
There's no reason not to switch to DocBlox is an overview of an Api documentation generator for PHP 5.3, which together with phpdox will replace the older phpDocumentor, not maintained anymore.
Practical PHP Refactoring: Change Unidirectional Association to Bidirectional targets the transformation of a pointer between two objects in a bidirectional reference, where each object can navigate the graph towards the other.
Offline web applications: a working example is, in fact, a working example of an HTML5 application that you can load in the browser once and then use forever after severing the connection with the server, or closing and reopening the browser. The goal of course, is to make a comparison with native mobile applications.

Who disagrees with me? First issue

2011-09-02T12:37:00.000+02:00

I've just sent to subscribers the first issue of Who disagrees with me?, a service providing a weekly link to an article guaranteed to challenge your thinking.
For example, readers who have subscribed to the PHP edition (selecting PHP as their preferred technology) are getting an article describing an advanced feature of Ruby that PHP lacks by construction.

If you want to jump on board, subscribe. I am pretotyping this service by selecting links manually: if there is a recurring interest in the list, I will transform it into a website covering other areas too (economics, or maybe music).
Who disagrees with me subscription