Noise is a huge issue at workplace, the modern trend of open-space offices too often means you end up having a noisy environment. Some people deal with noise much better than others, but unfortunately I’m not one of them and usually I’ve a fair amount of time, and money, searching for the best way to block, trying several combinations of noise isolating headphones and earplugs with different kinds of music.

Amazingly, at least for me, one of the most effective methods I’ve found was using a white-noise generator, and the theory is simple: our brain can easily filter and ignore flat, constant sounds (like a fan working in the same room or rain pouring outside). I ended up using SimplyNoise, a real simple web-based generator that plays white noise, pink noise and brown noise (more on noise colors here) with a few other tweaks. Usually work better with the more “rain-ish” sound brown noise.

// My class where Ninject
// will create and inject
// an instance of IWeapon
public class Samurai
{
    //  This is a Ninject attribute,
    //  if we switch to another
    //  DI container the code will break
    [Inject]
    public IWeapon Context { get; set; }
}

Fortunately Ninject is highly customizable and allows to change that behavior, the plan is to create a custom attribute and configure it so that Ninject can use it the same way it uses the Inject attribute. The usage will be similar but all the dependencies will be to local classes, the custom attribute can be something as simple as this:

public class InjectHereAttribute : Attribute
{
}

The class will now look like this:

public class Samurai
{
    //  Now there's no external dependency,
    //
    //
    [InjectHere]
    public IWeapon Context { get; set; }
}

Now Ninject must be configured to use the custom attribute, this can be done by creating an implementation of IInjectionHeuristic that recognizes the custom attribute:

public class CustomInjectionHeuristic : NinjectComponent, IInjectionHeuristic, INinjectComponent, IDisposable
{
    public new bool ShouldInject(MemberInfo member)
    {
        return member.IsDefined(
          typeof(InjectHereAttribute),
          true);
    }
}

And finally add this behavior to the Ninject Kernel using the Components collection, it will run along the existing components, namely the default implementation of IInjectionHeuristic, which means either the default or the custom attribute can be used.

// Add custom inject heuristic
kernel.Components.Add<IInjectionHeuristic, CustomInjectionHeuristic>();

Lately I’ve been growing a “pet hatred” towards applications that automatically post updates to Twitter or Facebook, specially those that do it often, I’m thinking in “I’m in [some place]” kind of posts of location-based services like Gowalla and Foursquare or the “Just listened to [some song]” updates of media players, just to name a few. The problem with these updates is that there’s no added value, nothing really relevant to share; while sometimes generated updates are useful, posting blog updates is the best example, in most cases a automated tool can’t add content, can’t share what’s so cool about that song or place, can’t share the context for that update. This often means a noisy timeline that people want to avoid and that’s why automated update services should be used sparingly, prefer sharing items explicitly and really sharing something rather that dumping stuff the timeline.

1. A light, portable and yet relatively sturdy tripod – I’m not a real nature photographer so I don’t want a “put any kind of lens with any camera, whatever the weight, whatever the weather conditions” tripod, I’m thinking in those neat carbon fiber Induro’s, I keep hearing good things about them.
2. A photographic monitor – Nuff said, a bigger monitor that uses an LCD technology with full color reproduction.
3. Some kind of centralized storage, other than external hard disks, to have a bullet-proof backup strategy of my photos and the rest of my documents; something with redundant storage and smart enough to automatically back them up to my online storage, and certainly not a Drobo: I tend to avoid solutions using proprietary formats.

And the best thing is you can browse it below, almost all of it! Although you may not have time to read the small print.

52 Photographic Projects [Kevin Meredith]

Email still is the communication pipeline for most people, myself included, so I tend to find a way to pull important but  non-email notifications to this medium (usually some RSS feeds). Twitter is no exception and this is a great way to import relevant tweets into your email (like the hashtag of the local photowalk you’re always missing…).

TweetyMail: It’s Twitter Over Email. And It Works [TechCrunch]

(Texto publicado originalmente no Diário2)


O iPhone tem uma grande vantagem em relação ao Android: um sistema operativo que corre apenas numa plataforma. Este tem sido, aliás, o caminho da Apple nos computadores e em tudo o resto, preferindo um sistema operativo orientado a uma arquitectura conhecida.

A Google, por seu lado, seguiu um caminho diferente para os dispositivos móveis: lançou um sistema livre e aberto a todos, em especial aos potenciais fabricantes que o poderiam adaptar às suas necessidades e assim conquistar uma maior fatia de mercado.

Uma das vantagens de se optar por um sistema exclusivo para uma arquitectura conhecida e para um único fabricante é que é fácil conciliar o os desenvolvimentos de ambos, permitindo ter um calendário de lançamentos único. O problema com o sistema Android é que cresceu imenso no último ano, cresceu exponencialmente em vendas, cresceu no número de fabricantes que o adoptaram e, mais importante, cresceu em funcionalidades e versões lançadas, e coordenar estes lançamentos com os prazos de cada um dos fabricantes não é fácil.

O exemplo disto é que nos próximos dias deverá ser lançada na Google I/O 2010 a mais recente versão do sistema, a 2.2, mas ainda são comercializados modelos com as três versões anteriores: 1.5 (que equipa os HTC Hero e Magic), 1.6 (presente no HTC Tattoo) e 2.1 (versão disponível nos dispositivos mais recentes).

Há uma cada vez maior fragmentação no universo Android, com todas as diferentes versões a coexistirem no mercado, a que se soma as diferentes variações de cada fabricante vai criando. Isto torna a vida complicada não só aos fabricantes como também a quem mantém os milhares de aplicações, ao ter de suportar todas estas variações (que contrasta com a tarefa mais simples de quem desenvolve aplicações para iPhone) ou optar por suportar apenas um subconjunto dos dispositivos existentes.

O Android está a crescer rápido, e com isso poderá no futuro tornar-se demasiado complexo e ramificado.