Blog

An illustration for a game I am currently working on. I will certainly have to clean it up a little before usage. It's my first new indie illustration, champagne!

There's something special with Processing and I love testing things with it. But I am not a great fan of Java.

I decided to have some fun and experiment with Scala, Eclipse and the processing libraries. It worked.

But, then I was hit by a question: assuming I create something funny with all this wonderful stuff, how do I ship it to people?

After some really convoluted attempts I found an ugly and half baked solution which still involved hard work for each and every new sketch.

A little bit disapointed, I opened Processing to see how easy it was to ship a sketch as a native application.

Here's a screenshot of the export panel.

Now, there's definitely something important to learn from this panel.

I think that Processing works, is minimalist and focuses on helping its user experiment and ship.

Every word is important in the last sentence:

• works
• minimalist
• focus
• helpful
• user
• experiment
• ship

That's a great lesson a lot of people should follow.

Thank you Processing :)

I am an org-mode user. I write things and I organize most of my life using org-mode. It made me code with emacs after many years of vim -yes, I know, coder's stuff is often boring-.

Since this blog was created I made a promise to manage it through emacs using org files. If possible without changing of blogging platform: Tumblr.

I used a few tools and coded some converters and I now have the following structure on my computer:

blog-fr.org     # the French blog content
blog-en.org     # the English blog content
picasa/         # images used by posts
labe.me/        # the static entrance http://labe.me

Plus some files which help diffuse, deploy and synchronize all this stuff, among which a good old Makefile to make things as automatic as possible.

Here are the main tools used by the system:

• tumblr-rb: a ruby implementation of the tumblr API with a useful command line interface
• googlecl: a command line client to manipulate google services' data
• Markdown.hx: a buggy Markdown to HTML converter written in haxe. After some hacks and filters it helped me convert org content into custom HTML
• elbow grease to create the haxe org file parser and the glue code (boooooring)
• even more elbow grease to test and debug the whole thing (even mooore booooooooring)

Finally:

• everything is published and synchronized from the same local repository
• using a simple keystroke in emacs or command line in the terminal
• the directory is versionned (git)
• I can prepare my posts without an Internet connection and I won't have to copy/paste the result in some HTML textarea
• TODO means draft and is synchronized to Tumblr draft for preview when required
• I publish simply by toggling TODO to DONE
• I can modify what I draft or publish, no need to connect to the Tumblr dashboard to correct a typo
• images are synchronized with picasa transparently and their URL is replaced inside the posts, using another hosting system would be really easy
• I can change my blog hosting system pretty easily since everything is on my machine
• the system can be improved with more elbow grease -add a local HTML preview, a better integration with Twitter/Google+/Facebook, better typography, automatic replace, two way sync, etc.-
• org-mode :)

If some org-mode user is interested I will gladly share the code -which is simple-. My emacs lisp fu is not good enough to code this in lisp without losing a lot of time but some emacs guru might be interested by the idea and give it a try.

In the meantime, I am pretty impressed with the result and the open possibilities!

It's less ugly but I still have a lot to do before the initial release.