Flickr

This is a test post from , a fancy photo sharing thing.

New blog

Well, after having posted a bit randomly for years now, I've finally found myself something to actually blog about: environmentalism and climate change. When I saw "An Inconvenient Truth" I was shocked. After that I kept myself in the loop and the things I've seen since then have shocked me even more. Therefor I'm going to start a new blog at the url where this blog was once located: http://blog.redgeonline.net I'll keep this old blog online for odds and ends and archiving, at http://trek.redgeonline.net

I'm going to check out Wordpress as an alternatative to Blogger, so it may be a little while before the new blog is up and running.

Living in the cloud

Well, it's my first macro-blog in a while. Ironically enough, it's microblogging that brought on this post.

You see, I, like many others, have recently discovered that microblogging, like Twitter, is about more than just letting the world know where you are and what you are doing from moment to moment (which seemed to me kind of dull and pointless, which is why I waited this long to try Twitter out). Of course, once I actually tried Twitter I found it has far more interesting uses, like posting some of those interesting facts or thoughts I sometimes have but which are to short for a full blog post.
But alas, it wasn't long before I was also introduced to the fail whale. This is what got me looking for alternatives to Twitter, preferably open source. This led me naturally to identi.ca. I tried posting here a few times, but in the end no-one I knew used identi.ca or would consider using it: if identi.ca hadn't offered to cross-post my updates to Twitter, no one would have read them. As for people to follow on identi.ca myself, I found that my tollerance for uninteresting dents decreased dramatically for people I didn't know.

So, I tried installing the laconi.ca microblogging service directly on my new VPS host: redgeonline.net. This went well, though it was a major pain that although I could create CSS for my custom skin (with the bamboo background, the one that integrates with the rest of my site: I've been thinking about moving this blog to that skin but I like the current one too much), I couldn't alter the output HTML. Tip to laconi.ca: no templating system is a major feature gap, fill it!
Well, here the trouble really started: what I wanted, and what didn't seem like a big deal what with all that talk of API's and open protocols, was a simple list with the updates of me and all my friends, no matter where they came from: Twitter or a laconi.ca host or something else. I wanted this list on my own server, not via yet another 3rd party service. Unfortunately, though laconi.ca allows you to automatically cross-post to Twitter via the Twitter API and to retrieve my friends so that I can automatically subscribe to them should they get an account on my server (which I doubt, and even then I'd be aware of it anyway), it's impossible to pull in friends' status updates. Why is this, I wonder? The API is there, is laconi.ca simply to proud to use it?

Normally I love the cloud: I've been using Google Apps ever since each of them came out. The driving factor: reliability and access. I can access my data from everywhere, and I can rest assured that it will not be lost overnight. Google reader makes sure that what I mark as read stays read across computers. Google calendar, which now even syncs with my Windows mobile phone, has my calendar items going back years: I've never lost anything because of faulty syncing, device malfunction, etc. (unlike the calendar I used to keep using Outlook). And Gmail: it just keeps getting better and better.

But on the other hand, since I've started investing more and more time into setting things up on my own server, I've been getting more and more sympathetic to the autonomo.us philosophy: let users stay in charge of their own data. On the one hand this would counter the reliability factor which I just pointed out, but on the other hand there's nothing like being in complete control of your own online presence (I must have profiles on more sites than I dare to count, and I maintain and update none of them).

The drawback, I'm finding, is that the cloud is not yet as accessible as advertised, and that if you want to connect to people, you're still forced to use 3rd party apps. Staying in charge of your own data, though idealistic, for now comes down to a lot of added effort and an end-result that is still miles behind the leading edge of 3rd party apps. So for now, I'm content to be another Google fanboy and to leave outdated breadcrumbs of my presence all over the web. The day that these traces are all drawn together will come in the end.

On the microblogging bandwagon

Untill now I've always declared microbloggers (Twitter,Identi.ca) to be silly, informing the world when they leave the house or take a dump. It turns out that I had the wrong idea about microblogging. I'm happy to report that I have repented, and am now happily microblogging along with the rest of you.

I've tried Twitter and Identi.ca. The latter seems to have more options, is more stable, and it automatically double posts on Twitter for me anyway, so why bother with Twitter at all? You'll find me at http://identi.ca/redge I've also embedded a widget in this blog.

In any case, if Google Wave becomes all they promise it to be, it will be a mute question anyway as I'll be handling all my communications with the world from there anyway...

Untill then, happy (micro)blogging: hope to hear from you.

Off GIT, after only a few days

After losing the entire revision history on one of my projects for no good reason earlier this evening, I've decided to stop using GIT. I'll allways remember it as the revision control system that showed me the many advantages to a distributed system (I'd been using subversion).

But truth be told, I was getting less and less enthused anyway: GIT really isn't that powerful a system, and there weren't many tools that could manage it, forcing me to the command line (I don't mind the command line, but using it constantly is a waste of time IMHO). I work with Eclipse a lot, and a tool for GIT of the same level as subclipse doesn't exist yet (there is a plugin with some integration, but it's not very easy to use and breaks a lot).

Now I'm on the hunt again, looking for the new best thing. Right now I'm giving Bazaar a try, and so far I like what I see. There's decent Eclipse integration and I'm told there are even packages to integrate it with Nautilus, although I haven't tried it yet. It also seems to be more widely supported, and it comes with nifty stuff like Trac and Launchpad.

As it is now, bzr looks like a keeper. But I don't want to sell anyone short: if someone can suggest an even better revision control system, my door is always open.

Smarty dereferencing/complex object calls

Note to self: next time I have trouble calling nested methods on an object in Smarty, use this:

http://code.google.com/p/smarty-php/issues/detail?id=3

Example:
{$object->methodReturningObject()->nestedMethod('with','complex',$arguments)}

GIT upload script

Since I'm on a shared host (Hostmonster), I don't exactly have full freedom. Not being able to serve a GIT repo is one consequence. Fortunately, GIT is resourcefull enough that even without the GIT daemon running, uploading the files is enough for people to pull them from the server, or explore them through git-web.

So for people in a similar situation, here is a script that will upload your GIT repo's to your shared host:

#!/bin/bash

# A script to create a bare clone of a GIT repo and upload it to a server for
# archiving or public distribution.
#
# Author: Romke van der Meulen 
# License: CreativeCommons Attribution Non-Commercial 3.0

# Check arguments
if [ $# -lt 1 ] || [ $# -gt 2 ]; then
   echo "Usage: git-upload (SourceDir) [TargetName]"
   exit 1
fi

# Define remote directory
HOST=user@host.com
REMOTEDIR=public_html/repo

# If no second argument given, the name of the uploaded repo is
# equal to the repo being copied
if [ $# -gt 1 ]; then
   NAME=$2
else
   NAME=$1
fi

# If the temp files already exist, remove them
rm -rf $NAME.tar.gz $NAME.git

# Begin procedure

   # Create the bare clone
   echo "Creating bare clone"                    && \
   echo -n "  "                            && \
   git clone --bare $1 $NAME.git                    && \
   # Tar and zip
   echo "Zipping"                            && \
   tar -czf $NAME.git.tar.gz $NAME.git                && \
   # Upload to target dir
   echo "Uploading"                        && \
   scp $NAME.git.tar.gz $HOST:$REMOTEDIR/                && \
   # Unzip at target dir
   echo "Unzipping"                        && \
   ssh $HOST tar -xzf $REMOTEDIR/$NAME.git.tar.gz -C $REMOTEDIR/    && \
   # Remove generated files
   echo "Cleaning up"                        && \
   ssh $HOST rm -f $REMOTEDIR/$NAME.git.tar.gz             && \
   rm -rf $NAME.git.tar.gz $NAME.git                   && \
   # Done
   echo "Succesfull"                    && exit 0

# Error encountered
echo "Unsuccesfull" && exit 2

Install it somewhere where you can get at it and change the remote config to reflect your own. Also, unless you like giving your password three times, I suggest you also upload your public key for automatic login. Once you've done this, all you need type is:

git-upload (repo dir) [remote repo name (optional)]

and you're all set.

Any questions, you know where to find me.