But I would like to look into the new Google font API.

The main problem with mechanisms like Cufon and SiFR is the legality of using the fonts. Most fonts dont come with a license to use them on the web. Therefore Google is building a library of new, open source fonts. You can use these fonts on your site, but also download them and use them in any work you like. Including print.

You can find all Google fonts in the Google WebFont directory.

Besides the WebFont directory, Google also serves you fonts through their new Google Font API:

The Google Font API helps you add web fonts to any web page.
Benefits of the Google Font API include:

• A choice of high quality open source fonts.
• Works in most browsers.
• Extremely easy to use.

Well, the choice of fonts is still very limited, but this will probably expand rapidly. The other claims are usually incompatible. This time it looks true.

Lets do a quick test. To use one of the new Google fonts in your project, just link to the @font-face definition and you’re ready to go.

<link href='http://fonts.googleapis.com/css?family=Reenie+Beanie'
	rel='stylesheet' type='text/css'>
<style>
	.googlefontapi {
		font-family: 'Reenie Beanie', arial, serif;
		font-size: 32px;
	}
</style>
<div class="googlefontapi">Type through Google font API!</div>

This css should result in this:

To use multiple types on your site, you can use mutiple link tags, but this would increase your http-request count. You can get more @font-face definitions in one request, just compose your link url like this:

<link href='http://fonts.googleapis.com/css?family=Reenie+Beanie|Droid+Sans'
	rel='stylesheet' type='text/css'>

What does it do?
Because most browsers implement @font-face slightly different, so google serves the right format for the browser of your user.
Cache headers for these files are set to the maximum so it will be very likely popular fonts can be loaded from the browsers cache.

If you want to use your Typekit fonts, you can use the Google WebFont Loader. This is a JavaScript library that gives you more control over the font loading and allows you to use other font-providers.

Note: don’t use font-face for your large texts. Rendering in IE stays ugly. For bigger things like titles, it’s perfectly usable…

My interest was triggered because I’m building a RepRap and they have one finished and building a new one. People can use the Timelab infrastructure to print their own 3D models or use the other gear they have. Not only can you use it, they can teach you how to build those things yourself.

To do that, they organise a range of workshops from open labdays to an introductory course to Arduino programming. That is exactly what I was looking for. If you are interested in taking this course on April 20, check out the details here! It is free but places are limited so hurry.

I really wish the guys at Timelab the best of luck, this is a great project!
You can find all the info you need on http://www.timelab.org.

Update: I just received a mail from Timelab to let me know they are organizing a second Arduino workshop on April 27 due to the success. – More details on http://www.timelab.org/Arduino

First, lets see what a document-oriented database is.
You know about scheme-oriented databases like MySQL, right? Before you start you’re project, you start thinking what data you want to save. Once you know that, you have to start breaking that up in databases, tables, strongly typed fields and hope you don’t have to leave that path too often during the project…

With document-oriented databases this is not the case. You just create a database and start developing. Every time you need to save some data, you just create a document, add the fields you need (for a shopping card you’d probably save a user_id, date, price, all the items, …) and save it to the database.

From Wikipedia:

As opposed to relational databases, document-based databases do not store data in tables with uniform sized fields for each record. Instead, each record is stored as a document that has certain characteristics. Any number of fields of any length can be added to a document. Fields can also contain multiple pieces of data.

Lets get physical!
I assume you are running on osx 10.6 or higher and have some notion of php

Got 10 minutes?
I’ve chosen for MongoDb after some (quick) looking at benchmarks and comparison charts and it seems Mongo DB is slightly faster at execution. But there are others out there;

• Apache Jackrabbit (Apache License)
• Apache CouchDB (Beta software), (Apache License)
• FleetDB (MIT License)
• Redis (BSD License)
• Riak (Apache License)
• StrokeDB (Alpha software, MIT License)

So, lets install MongoDB. I’ve chosen for the painless route and installed it using Homebrew. (If you don’t have Homebrew installed, check out the github page)

brew install mongodb

Next, we need to have the mongodb php extension. You could compile the .so file youreself, but again, but again, I chose for the easy solution. Grab the right .so file and place it in your php extension dir. Then add this line to your php.ini file;

extension=mongo.so

Restart apache and you’re ready to go!

Create a folder where you want your databases to reside and fire up mongodb;

mkdir -p ~/data/mongodb
mongod --dbpath ~/data/mongodb/

Go ahead and create a plain php file to play with.

First, we need to establish a connection with our MongoDB server;

$conn = new Mongo();

This will connect to the server on your localhost running on port 27017. You can add a parameter to specify the server location (eg: new Mongo(“mymongoserver:65432″);).

Then select a database like this;

$db = $conn->dbname;

and select a collection;

$albums = $db->albums;

That’s it! Now you can start manipulation the database.

Let’s create a document;

$album = array(
   "title" => "The Fame Monster",
   "artist" => "Lady Gaga"
);

Now we need to add some tracks. In scheme-oriented database system you would create another table with tracks, and link them to the album with an album_id. Not so document-oriented database systems;

$album["tracks"] = array(
    1 => "Just Dance",
    2 => "LoveGame"
);

Done! The tracks are saved in the album document itself, not separate documents.
Now we can insert it into the database;

$albums->insert($album);

You can read out the documents with the find function;

foreach($albums->find() as $album) {
    foreach($album as $k => $v) {
        echo $k . ": " . $v . "<br />";
    }
    echo "<br />";
}

And there we have a list of all ablums on the screen.

I just wanted to show you how easy it was, if you want to find out more, here are some links;

• http://www.mongodb.org
• http://php.net/manual/en/mongo.tutorial.php

If you start playing with is, please do let me know what your think of it.

Because we’re not used to working with electronics, the BOM (Bill of Materials) of the RepRap (as found on the RepRap wiki) looks pretty frightening at first. After a second, third and fourth look things became a bit clearer.

We looked up every part in different online shops that are best for us (Belgium / Europe) and have assembled ready-made ordering lists for most parts. We chose to buy some parts pre-assembled, while the original BOM mentions them separately (to make our life a bit easier).

The original BOM can be found on the RepRap Wiki here. This is our BOM in PDF format.

Some remarks:

• Bars: All necessary bars for X/Y/Z axises are 1 item, since they’re 3 times the same
• Belts: X and Y belt are 1 belt of 10mm width, split into 2 belts of 5mm width.
• m5x20-mudguard-washer: If you can find an M4 instead of M5 that’s better, but the shop we bought it in didn’t provide it.
• extruder: We found someone on the forum who sold the barel and nozzle combined. Makerbot sells these parts separately.
• electronics: We decided to buy Fully Assembled kits, because we’re no soldering heroes. The only thing not available fully assembled at Makerbot was the endstop, so we bought an extra kit to have a backup when we screwed up (They’re not expensive)

Some other things you’ll need:

• Thin sheet: This is metal that can be gotten from anything (for example soda cans)
• Thick sheet: Sturdy plates meant as printing base. We’ll use MDF for this (Get this at your local do-it-yourself store)
• Soldering set
• Magnifying glass (to put together PCBs)
• Electronic wiring
• Jumpers
• Soldering tin

At the moment we have ordered everything int he BOM except for the Makerbot items (Some items were out of stock, they should be up again in a few days / weeks). We’re also still looking for someone to print the reprap-printable parts for us, we’re looking on IRC / Forums for those.

Time and money spent on the project so far:
Time: About 8 hours trying to make a complete list of everything we need and grasp the big picture of the RepRap
Money: € 401.44 in parts and € 35.00 in food

We’ll keep you posted on our progress!
Wish us luck.

We are keeping all posts on this topic in this post.

RepRap is an open source replicating rapid prototyper, available under the GPL license. You can assemble it with (most) parts available in your local hardware shop. More then fifty percent of a new RepRap can be printed out by other RepRap’s.

We decided to take on this challenge. Without any knowledge on electronics we’ll figure out how to build one ourselves and will document this process step by step as we go along. We hope others can benefit from this and hope to find a helping hand when we screw up.

The model we are going to build is the Mendel. This is already the second generation that the geniuses at RepRap created.

Underneath, you’ll find a list of posts, which will expand in the future. Each one referring to a night of fun we had while figuring this thing out and building it.

• Step 0: BOM

Bernard, Marlies, Joren and myself formed a team and created everybody.lovesbeer.com. A site to find Belgian beers you’ll probably like based on the profile you assemble by liking & disliking beers.

Because the contest is growing each year, this year not every entry is available in the voting. A team of judges put together a shortlist of 20 entries (out of – give or take – 200). Since our beer-application lacks some functionality and isn’t completely finished, we didn’t make it to the shortlist. But there is no timing weeping over that because…

Our friends who put together tablesurfing are in the shortlist. Gorillaminds (the name of the team) is Jan (Openminds), Jeroen, Jelly (Gorilla webdesign) & Benny (Gorilla webdesign). Because they are the only Belgian team to make it to the shortlist, it’s their job to defend hour honor. But you can help!
We need everybody to vote, now! Voting is only open for 2 days…
How to vote?

1. Point your browser to http://r09.railsrumble.com/entries
2. Click “I want to vote”
3. Log in or create an account (really painless)
4. Check your account page and open the tablesurfing entry
5. Give stars accordingly to what you think they deserve
6. You’re done, but now that you’re there you can vote for the other entries also if you like.

The whole team will be great-full and I’ll keep you posted on the results later on!

Download the Android SDK

First of all, you need to download the Android SDK. You can find on the Android developers site, in the SDK section. I’m using the mac x86 1.5 R3 version in this tutorial which is 175MB when writing this post.
When downloaded, extract the zip file (I recommend you do this in a folder you know will never move, like /programming/sdk) and we are finished with this folder for now.

Installing Ecipse and the Android Development Tools

I’m using Eclipse for most of my development and it looks like google did a great job on their Android Eclipse plugin, so that’s what we’ll use for our development.

1. In order to use this plugin, we will need Eclipse itself. Download Eclipse for java developers from the Eclipse site. I recommend the Cocoa version.
2. Extract the downloaded file into your /Applications folder and fire up Eclipse.app.
3. In your application menu select: Help > Install New Software …
4. Hit the Add button and give a name that makes sense (“adt” or “android development” tools for example). For location, enter https://dl-ssl.google.com/android/eclipse.
   
5. When you push the Ok-button, Eclipse will load the the available components. Select Developers Tools (make sure the nested components are checked as well) and hit next.
   
6. You’ll be presented with an overview of installations, just click next. Then accept the license and hit finish. Eclipse will now install ADT.
7. Restart Eclipse.
8. Now we need to let ADT know where he (or she) can find our SDK. Go to your preferences (windows: window > preferences. Mac: Eclipse > preferences).
9. In the left panel, select Android (you might get a warning your SDK is not setup yet, but you can ignore that because that’s what we are doing now). Click browser and navigate to the sdk folder we extracted. This must be the root map you downloaded. The one with folders like tools and platforms in it.

Create an Android app.

Now that we have everything ready to go, it’s time to see if everything is set up correctly and create our first Android app.

1. In your menu, select: File > New > Project.
2. In the dialog that should pop up, select Android Project and hit Next.
3. Now we can set some parameters for our new project. Give a name (“HelloAndroid” for example).
4. Choose a build-target. Unless you have some specific needs, you should choose the lowest version possible. We’ll go for 1.1.
5. Give an application name. This is the human readable name for your app.
6. Give a package for your source to go. I’ll go for be.dimitrivanheucke.blog.android.helloandroid.
7. Make sure Create an activity is checked. This will create a Class for us that is our main starting point. Call it HelloAndroid
8. Your dialog box should now look something like this;
   
9. Hit Finish and ADT will create your project

Testing your application

Before we can test our application, we need to create an AVD (Android Virtual Device). This will be used to present our application in the emulator.

1. Open your terminal and go to the tools folder inside your downloaded SDK folder.
2. To create an AVD we need to specify a target. To get a list of targets type;

   ./android list targets
   

   The outcome should look like this;

   Available Android targets:
   id: 1
        Name: Android 1.1
        Type: Platform
        API level: 2
        Skins: HVGA (default), HVGA-L, HVGA-P, QVGA-L, QVGA-P
   id: 2
        Name: Android 1.5
        Type: Platform
        API level: 3
        Skins: HVGA (default), HVGA-L, HVGA-P, QVGA-L, QVGA-P
   id: 3
        Name: Google APIs
        Type: Add-On
        Vendor: Google Inc.
        Description: Android + Google APIs
        Based on Android 1.5 (API level 3)
        Libraries:
         * com.google.android.maps (maps.jar)
             API for Google Maps
        Skins: HVGA (default), HVGA-L, QVGA-P, HVGA-P, QVGA-L
   

3. Now we can actually create our AVD. Type;

   ./android create avd --name myavd --target 3
   

   Of course you can change the name (myavd) in whatever you like. I used target 3 so we can use this AVD for other projects as well (for example when we integrate Google Maps).
   So we will have a 1.5 OS on our virtual device but we can run any application that targets that sdk version or lower.
   We are done with terminal now, so we can go back to Eclipse.

If, like me, you get some errors on your console panel at the bottom of the window looking like this;

[2009-08-12 15:02:57 - HelloAndroid] no classfiles specified
[2009-08-12 15:02:57 - HelloAndroid] Conversion to Dalvik format failed with error 1

You should go to the properties of your project (right mouse click on the project > properties), go to java build path and make sure Android 1.1 is checked in the Order and Export tab.

4. Now we are ready to test or application! Hit the run button in the toolbar at the top of your window and select Android Application in the Run As dialog that pops up. After clicking Ok your emulator should load and open your application. This can take a while, your emulator first has to install your application. You might have to unlock the screen first by clicking on the menu button at the bottom of your (android) screen.

That’s all for setting up your environment and run a first test project.
I’m planning on doing some more of these but haven’t decided on the topics yet. So if you want to see something in particular, let me know in the comments. For the next one I was thinking about integrating Google Maps.

A few weeks ago we started our first commercial RoR project. For this product-catalog site we wanted an easy solution for image uploading and decided on Paperclip. This needs ImageMagick and that gave us some worries.
So if you are struggling with installing ImageMagick and getting it running for Ruby, try these steps;

Download the MacPorts dmg-installer, a packetmanager for osx, and install it.
When installed, fire up terminal and start typing;

sudo port install ImageMagick

This will take a while, go get yourself a coffee and when the installation is finished run the following commands

sudo port install ImageMagick
sudo gem install rmagick

That’s it, I hope you enjoyed your coffee because you can grab the code on github and get coding now.

For a good introduction on how to use paperclip, there is a good railscast avaiable for that!

Oh, the guys from Openminds and Gorilla webdesign decided arrrrcamp deserved a second edition. That is comming on October 16th, so reserve your spot at arrrrcamp.be (for free). I’d recommend not to hesitate because it looks like reservations are flying out!

dConstruct is the affordable one day conference for people designing and building the latest generation of social web applications.

Steven Johnson kicked it off with a talk on the long history of the geoweb and maybe even the first one. Back in the 18th century, when Cholera was ruling the streets in London, the need emerged to map all the death in order to find a potential source of the decease.
This leaded to the geoweb and how it is influencing the social web. The Urban web is what is happening.

Next up stage whas Aleks Krotoski with one of the best sessions of the day for me: Playing the web.
She talked about how the game- and web industry can work together more often to make the web a better place in terms of the experience.

In the afternoon Tantek Çelik gave a promo talk on microformats with his talk: Social network portability.
This encouraged me to pick this ‘technology’ up and start to implement it. I recommend his book: Microformats: Empowering your markup for web 2.0.

As a absolute highlight of the day, Jeremy Keith gave the closing session: The system of the world. I really can’t spoil it for you guys because a description would not even begin to describe his session. I will give you a link as soon as the podcast for this one is online!
You can find his slides and a full write-out of his talk on his site!

I really enjoyed this inspiring day and make sure to register for the next editions!

For most sessions, podcasts are available via the dConstruct site!