chester's blog

technology, travel, comics, books, math, web, software and ramblings

Software

A workaround to fix the Firefox emoji keyboard shortcut on macOS Sonoma

18 Feb 2024

macOS 14 (Sonoma) broke the “Emoji & Symbols” keyboard shortcuts (fn/🌐+e or control+cmd+space) on Firefox: instead of opening, the emoji picker briefly flashes and disappears:

The "Emoji & Symbols" panel briefly flashes and disappears

If you use the “Edit… Emoji & Symbols” menu, the picker works - but it’s annoying to reach out for the mouse whenever you need an emoji or special character! I thought such an inconvenient bug would be fixed quickly on a minor Firefox or macOS update, but months passed and the bug was still there.

Between annoyed and curious, I dug the source code a bit and wrote a patch that fixes it, and also a secondary problem with the fn/🌐+e shortcut (introduced in Monterey as a replacement/alternative for control+cmd+space): it works sometimes, but when it does, it also writes the letter “e” where the cursor is, which is equally irksome.

For reasons that I will explain below, Mozilla did not accept the fix. They are working on another solution, but it will take a while to be released. Since many people have the problem right now, I decided to share some details about my fix here, alongside with instructions for applying the patch to the official Firefox source code or downloading my patched version - which I rebranded “EmojiFox” to avoid confusion and respect Mozilla’s trademarks/license.

UPDATE: In January 7th, 2025, Mozilla released Firefox 134, which contains the aforementioned fix (and they were kind enough to mention the work described here on the beta release notes ❤️). I strongly recoomend that you just update your browser instead of donwnolading the outdated build below, and swittch back to the official release if you are still using mine. I’m keeping the downloadable file here for historical purposes only.

Migrating blog comments from Disqus to Staticman

14 Feb 2024

Staticman's logo by Erlen Masson (https://www.erlen.co.uk/), reproduced under a premise of fair use - a minimalist/negative space illustration of a Clark-Kent-y head and partial torso, but wearing a Superman-style cape, the cape tied with a bowtie. Below the text "Staticman", then "Static sites with superpowers"

In this age of controversial social media platforms, having a blog is one of the few remaining opportunities to keep ownership over your content. There are several good solutions around to publish and host one, but Jekyll and GitHub Pages are a great (and free) combination for people like myself who are happy hacking a little bit - except for not providing a comment system out of the box.

For years, I filled that gap with Disqus - a service that hosts your comments in exchange for a bit of advertising space. It was great at first, but over time ads became heavier, users were pushed towards creating accounts and abusively tracked. Moreover, hosting comments externally affects search engine indexing, and over time this all caused people to comment less and less, so I decided to bring the comments back to my blog.

A comment system isn’t a very complicated app, but it would be another database that I’d have to care for, and a departure from Jekyll’s static generation model that served me so well. The ideal solution would be to store comments in the same place I store posts: a trusty GitHub repository. Jekyll can read data files to show the comments, and all I needed was to host an app somewhere that would create those files when a new comment is written.

I almost coded that app myself, but Eduardo Bouças wrote and kindly shared Staticman, which does precisely that. Sure, I still had to host/configure it, adapt the blog to send it the comments (and read them from the repository files), and migrate the old comments from Disqus. These things combined took me a couple days, so I thought I’d share the process here.

Budget-friendly hosting for personal projects

20 Nov 2023

UI button

People get surprised when I tell them I keep all my personal software projects running on a single server, and that it costs me roughly a cup of (fancy) coffee per month. This post explains how I do it, and how you can do it too!

Why bother?

Every now and then I build a personal project that requires hosting on a server - sometimes it’s a website, sometimes a back-end API for a watchface, or even a multiplayer game server. In any case, it is tempting to use a free service or self-host, but eventually some of those prove to be useful to other people (or myself) on the long run, requiring a more robust solution.

Sure, one can always embrace the DevOps culture and build the projects with tooling that describes their infrastructure needs in code, deploying on a cloud provider. That works, but comes with a price tag that might discourage building new projects, and you don’t learn a lot about how things work behind the scenes.

In contrast, configuring and keeping a server up in a cost-effective, secure and robust way is a fun challenge in itself and a great learning experience. Even if you have a team or a service that does it all for you, getting some hands-on experience with servers makes you build better software, as you’ll be more aware of the constraints and trade-offs involved when it is deployed.

Unlocking a dumb electric lock via Home Assistant (+ ESPHome + ESP8266)

15 Dec 2022

In the last post I described how I used an ESP8266 board to detect when my ancient doorbell rings, and trigger a notification on my phone. This time, I’m going to use the same board and a relay to unlock the front door, which, combined with the ring detection, will allow me to get deliveries past the front door, open it for visitors, and even unlock both that door and the internal one (which already has a smart lock) when I arrive home!

ESP8266 and relay shield

Making an old-school doorbell "ring" on Telegram (via Home Assistant + ESPHome + ESP8266)

29 Oct 2022

After years of living in single-room condos, we decided to try a more spacious, two-store house, which has a very old and low-tech doorbell: a button on the door triggers a “ding-dong” classic doorbell - very easy to miss if you are on the upper floor, causing all sorts of issues with deliveries.

Sure, I could make it ring louder, but it would be annoying for anyone on the lower floor. And I also want to automate other hurdles related to package delivery, so I decided to first get the doorbell to ring into my Home Assistant setup (where I can trigger all sorts of automations).

Atari 2600 on a breadboard, part III: tidying up and adding the TIA (video chip)

25 Jun 2021

Tidying Up

In the previous posts I made the CPU work on the breadboard, then added a cartridge connector, all using jump wires - which can be easily reconnected, labeled, etc., but have a downside: they disconnect easily. Coupled with the equally flimsy cart connector, all my attempts at moving on with the project would result in failures.

After seeing Ben Eater’s beautiful breadboard computers I decided to rewire the boards I already had. For that, I’d have to rethink my cartridge connector: instead of having the jumper cables going out of it (left), I got some long pin female headers that extended the pins so the connector now fits the board like any other chip (right):

cart, before and after

Atari 2600 on a breadboard, part II: reading a cart

14 Feb 2021

Previously…

A long time ago I grabbed the three chips from a broken Atari 2600 (Jr.), to see if I could build an Atari with them on a solder-less “breadboard”. My first attempt (post here) was to drive the CPU with an Arduino, which showed the chip advancing through what it believes to be memory, but is actually just a single “no operation” (NOP) hard-wired instruction:

cleaner version of the 6507 memory walk on a breadboard

It took some time (between finding the right connector, 3D-printing a part, figuring out the wiring and fixing the Arduino software), but I finally moved on to the next step: plugging a real Atari cart and seeing some actual code running!

Detecting TV power state via USB

03 Jun 2020

One convenient feature of Chromecast is that it turns on your TV automatically when you connect to it - as long as your TV has HDMI-CEC. Mine doesn’t, but it is already remote-controlled via Raspberry Pi, and thanks to Home Assistant, I can easily detect when the Chromecast is in use, so in theory I could just blast a command to the IR when it switches away from “off”.

There is just one problem: Home Assistant doesn’t know whether the TV is on or off. If it is already on when I start casting, sending the command will turn it off - the opposite of what I want. Also, I would like to turn the TV off when not using the Chromecast (something it doesn’t seem to do, even with HDMI-CEC).

Enable dynamic DNS (DynDNS, Duck DNS, etc.) inside networks without NAT loopback support on router

18 Aug 2019

Dynamic DNS providers like DynDNS or Duck DNS are great to let you access software like Home Assistant running on your properly secured computer or Raspberry Pi from anywhere.

One problem that I was having with them: the custom URL did not work inside my network, just outside. That happens because my router does not support NAT loopback, blocking any requests from the internal network to the external IP (which is what my custom domain points to).

(Cheap) 433Mhz Leak Detectors in Home Assistant via Arduino + OpenMQTTGateway (with Telegram alerts)

30 Jul 2019

Water incidents in a condo can be catastrophic, and surely things like shutting your main water valve when you go out for long periods and having the proper coverage in your insurance are important. But for added peace of mind, leak detectors aren’t a bad idea.

When I saw these $3 leak detectors on eBay, I decided to give them a shot. Not only for low price, but also because they used 433Mhz RF - the same tech I use to voice-control my lights from a Raspberry Pi.

Once they arrived, I ran RFSniffer and indeed, when they get wet, the Raspberry Pi prints a different value for each sensor - so it should be easy to wire up an alert system… right?

Using Ansible to configure a Raspberry Pi (Home Assistant, LIRC, 433Utils, Z-Wave, etc.)

13 Apr 2019

A while ago I built a couple inexpensive hacks that added voice-command to my tv and then to my lights using a Raspberry Pi, Google Home Mini, infrared and RF radio. Since then, I added other things, which prompted me to move the hacks into the popular Home Assistant home hub software.

With so much of my routine depending on that setup, backup became a concern. I’d make an occasional copy of the SD card with dd, but that isn’t a good long-term solution. Ideally, I wanted to rebuild my setup easily, should the card get corrupt, slow or just wrecked by my ongoing hacking.

Enter Ansible. Sysadmins use it to write “playbooks” that represent the changes they would manually apply to a server. If done right, such playbooks can be applied to an existing server (fixing any broken configs), or a brand new one (to recreate its services).

The Raspberry Pi is just a (tiny) server - meaning hobbyists can use Ansible as well!

I’m not an Ansible expert (there are better places to learn about it), but my Ansible configs and these notes may be useful for anyone interested in automating Raspberry Pi setups (for home automation or anything else).

Controlling RF outlets from a Raspberry Pi

26 Dec 2017

IKEA floor lamps aren’t bad - as long as your house has sufficient outlets with properly wired and positioned wall switches. Mine doesn’t 😐 and, being a renter, I can’t simply rewire them, so I decided to try the Etekcity RF-controlled outlet kit.

For less than CAD$ 60 you get five outlets, which can be turned on and off individually by the two included remotes. Not a bad deal, and sure an improvement from the odd switches (and the built-in ones on the lamps). But given I already control my TV and sound bar from Google Home with a Raspberry Pi, it wouldn’t be much of a stretch to also have voice control over the lights.

outlets

Motion-sensing, Arduino-based Washing Machine Alarm

22 Dec 2017

I don’t iron clothes. Heck, I don’t even own an iron - quickly folding clothes right when I remove them from the dryer works for most of them (and a steamer does the job when that fails).

Problem: my current machine has a very low and short audio warning, so I often miss when it is done, ending up with wrinkled clothes. 😔

I thought it wouldn’t be too hard to build a device that detected when the machine stopped moving and alerted me in a more extravagant way. Having never played with raw accelerometers before, I would at least have some fun trying!

Voice control for a non-smart TV (with Google Home, a Raspberry Pi, LIRC, nginx, Lua and IFTTT)

10 Dec 2017

Despite my privacy concerns, I could not resist the low price of the Google Home Mini. It is really convenient to control the ChromeCast with it, but turning my (non-smart) TV on/off, or switching the input between different devices still required reaching the remote…

…until I hacked a bit!

In a nutshell: IFTTT turns Google Home commands into HTTPS requests towards a Raspberry Pi. There, nginx triggers some Lua code that runs LIRC, which generates IR signals into a transistor that amplifies them to two IR LEDs. Complicated, but works!

Atari 2600 CPU running on a breadboard

06 Sep 2017

Introduction

A year ago, Ben Heck hand-soldered an Atari 2600 on a protoboard (and, as usual, turned that into a portable console). The idea of manually re-assembling the console for which I had already hacked together a game and an emulator sounded very exciting (and educational) for me.

The show crew always publishes schematics for his projects, so while I waited for that, I started de-soldering the chips and cartrige conector (and a few extra components, why not?) from an old Atari Jr. board I had lying around. De-soldering is hard, but eventually it was done:

An Atari VCS (Jr.) board, without several components

The schematics, however, never came. That episode’s GitHub repository only includes the original Atari’s block diagram, so I shelved the plan. But more recently I stumbled upon a series of blog posts in which David Barton describes how he built a 6502-based computer (a 65c02, to be precise) on a solder-less breadboard.

Those boards aren’t as sturdy or portable as traditional printed circuit boards, but the freedom to tinker (and make mistakes) sparked my flame once again, so I decided to give the project another shot. I started by reproducing his first two posts, but adapted to the Atari’s 6507 and adding a couple tweaks.

Unbricking a WNDR3700v3 (NETGEAR N600) wireless router

18 Mar 2017

One day I decided to install an alternative firmware on my NETGEAR N600 in order to tweak lower-level settings and try to minimize frequent (and very frustrating) disconnections on Splatoon. But the setup failed, effectively bricking the router.

“No sweat”, I thought, “let me just put it into some sort of recovery mode and flash the original firmware into it”. For this router, the idea would be to transfer the firmware via TFTP - which works by setting up a computer with fixed TCP/IP configs and starting the transfer at the right time during the boot process.

That didn’t work either.

At that point, I realized this fix would require some physical hacking.

Connecting a classic (ADB) Apple keyboard to a modern (USB) PC using a regular Arduino

27 Dec 2016

When I saw this person building a Raspberry Pi inside a vintage Apple Keyboard, I thought it could be a comfortable way to play Apple II games on a TV. More important, I happen to have an Apple Extended Keyboard II just waiting for such an experiment…

Keyboard + Arduino

My winter holiday plans did not include going outside, so I wanted to build it with parts I already had. But the hack uses an Arduino Pro Micro (with a little help of the TMK Keyboard Firmware Collection) as a converter between ADB (the interface used by the Apple IIGS and older Macs) and the familiar USB, and I only had a regular Arduino (actually, a Leonardo-compatible clone).

I wasn’t sure that would do the job, so before tearing the keyboard apart, I decided that my first experiment would be an attempt to connect it to my computer.

Building a Pebble app with C, JavaScript and Rails (Toronto Transit Time)

11 Dec 2016

Toronto Transit Time splash screen

Earlier this year I was looking for an app that showed predictions for Toronto streetcars/buses on my Pebble smartwatch. To my surprise, I could not find a single one that worked the way I expected it to (or that worked at all, to be honest), so I decided to build my own.

Little did I know that getting fast and reliable predictions on my wrist wasn’t just a matter of writing C code on the watch - it also required code running on the phone and on a server. Totaly worth it: I use Toronto Transit Time almost daily - and I’m not the only one.

This insight of the development process was originally intended to become a presentation for the likes of PebbleTO, but given the uncertain future of Pebble (recently acquired by FitBit), I decided to just publish it here as a supplement to the application’s source code.

Building a Bluetooth-Controlled Dry Ice Fog Machine

08 Apr 2015

Last weekend brought an interesting challenge: to create a remote-controlled, small-sized dry ice “fog” dispenser for a company event. In the end it wasn’t used, but I had a lot of fun building it anyway. Here is how it was done:

Building bash from source (Shellshock mitigation for Ubuntu 13.04 and other unsupported distros)

25 Sep 2014

Shellshock is a serious server security issue that was made public yesterday. The best fix is to apply security updates from your Linux distribution, as they become available.

If that is not possible for any reason (e.g., unsupported distros, like the Ubuntu 13.04 boxes we have not killed yet), you will need to compile bash from the source (including all the patches) - which may be confusing if you are not used to build C/C++ software “by hand”.

There are some scripts that compile and install a new bash (like shellshocker.net’s curl https://shellshocker.net/fixbash | sh), but they assume you are ok with the latest bash version (4.3), and I needed to stay with 4.2. Here is how I did it:

Connecting a PC (DB15) Gamepad to a Raspberry Pi

17 Aug 2014

A Hack is Born

You never know what you’ll find at Active Surplus - a must-go Mecca for electronics enthusiasts in Toronto (pics). Last week, I stumbled upon a box full of PC gamepads - at $2.50 each!

They used an old connector (see below) that would require an USB adapter, but I had a better idea: connecting them to a Raspberry Pi. Bought one (discounted to $2) and hacking ensued.

2048 2600: The 2048 game for the Atari 2600

25 Mar 2014

As everyone else on the planet, I got hooked on 2048 and amazed by the variants that sprouted. Its simple rules and graphics are one distinctive characteristic. “It’s so simple”, I thought, “that it really could have been done on an Atari”. And once you have such an idea…

That’s right: this is a version of 2048 for the Atari 2600! It took me about 16 hours of work to get to a playable prototype, and about 50 hours for the final version, spread over a couple weekends and nights during which I was refining the core game and squeezing features like sound, two-player mode, and a high score.

During this period it briefly made the front page of Hacker News, received lots of great feedback on Atari Age and RVG, and got a couple of contributions (bug fix, PAL support). The 2048 source was also helpful - even though I had to rethink the whole shifting/merging strategy, it provided a nice foundation with very readable code.

The project page has all the instructions and files you need to run it on an emulator, on a real console or even in your browser. The remainder of this post shows some technical notes (which can also be found at the main assembly source file).

Running ruby2600 in a browser with Opal

16 Feb 2014

ruby2600

Last year I challenged myself into writing an Atari 2600 emulator using Ruby in time to present it at RubyConfBr 2013 - thus ruby2600 was born. When I found Opal, a Ruby-to-JavaScript compiler, I felt it might be fun to run the emulator on a browser.

It runs even slower than in MRI and is far from polished, but works. To watch it, just click the button below and wait until the black lines get replaced by Pitfall Harry slooooowly running to the left (sorry, no key bindings for now).

Keep reading if you want the gory technical details!

Going from WordPress to Octopress

15 Sep 2013

I don't always write blog posts, but when I do...

I could not express enough gratitude to the WordPress developers for offering the world a free, open-source, professional-quality blogging platform. Being based on a LAMP stack means it can be hosted pretty much anywhere with very limited resources, giving me freedom to change hosting services without any impact. Having a powerful admin panel, hundreds of plugins and being open to change means you can do pretty much anything with it.

One thing that I never liked, however, is the dynamic aspect: whenever you request a post, Wordpress has to retrieve information from a database, mingle it with HTML templates, call plugin code, build the page and then serve it. Surely, there are good caching plugins to alleviate the burden, but that is never as fast as plain old HTML. It also means there is software running on the server, which needs to be patched and catered.

Octopress has a more “back-to-the-basics” proposal: instead of running on your server, the software runs on your computer. Whenever you need to publish a new post, it generates the HTML pages for the whole site, then updates anything that changes. It is not a new approach, but its twist is that it uses tools that are familiar to modern web development, such as git and Markdown.

The big challenge was migrating 12 years of blog posts from Wordpress (some of them already migrated from other platforms and containing multiple flavors of horrible HTML). Octopress’ built-in migration wasn’t up to the task, but Ben Balter’s WordPress to Jekyll Exporter did the trick - you just install it on your Wordpress, run the export and copy the result to the source folder. Done.

Of course I had to manually fix lots of small things - for example, all my YouTube/SlideShare embeds were broken, because they are based on <iframe> tags, which were not imported. But that is what weekends are for, and I am very happy with the final result.

Things like Twitter/Facebook/Google Analytics integration are already baked in - you only need to enter your credentials on the config file. Others (such as Facebook OpenGraph) can be easily added to the simple template structure. There are already a few themes available, but I found that some color adjustments on the standard one gave me a pleasant look - not to mention lots of improvements that were desperately needed on my former HTML, like responsive design and less blocking JavaScript.

There is still a lot to fix (such as automating minification/joining of scripts and styles), but I am amazed by the performance improvement, the convenience of using GitHub as storage and the abscence of security hassles. It is definitely not for the general public (you have to do lots of things manually, making a blogging service like Blogger or an easy-to-use software like WordPress more suitable for such an audience), but if you like to hack and feel comfortable with an Unix shell, git and plain text editors, Octopress is the way to go!

UPDATE: Forgot to mention that it won’t handle comments. But it is easy to migrate them to Disqus (as usual, a WordPress plugin will do the trick), then just add the Disqus ID to the Octopress config file. Easy!

Should GMail blacklist spam senders?

08 Aug 2013

My friend FZero said today on Facebook:

Dear GMail: when I mark something as spam, you should BLOCK that email address from ever sending me anything again.

and my answer got a bit too long for Facebook, so here it is:

[TL;DR: Statistics say it would not work well for everyone, but might work for you, but Google is about large data sets, not (directly) about you, so if you want it, hack the planet!]

I’m not really up-to-date on the subject, but let’s assume the core of what GMail does behind the scenes is still a well-balanced “naive” Bayesian probabilistic approach for “spam/unsure/ham” classification (possibly fine-tuned by Google’s secret sauce of massive data analytics).

I remember (but can’t find right now) follow-ups to Paul Graham’s original work (which kickstarted the technique from a statistical indicator into a “99%+” efficient spam filtering technique) pointing to data/reproducible experiments suggesting that most “field knowledge” applied to the data sets (like, for example, bumping the significance of the From email address) of specific email tokens did not improve the efficiency metrics, and in several cases did indeed decrease efficiency.

However, a core point was that the inclusion of headers both in the both the database scoring and the composed score for each message (along with careful tuning of token identification to improve token database hit ratio) *did* improve the efficiency of the classification, so there *may* be some gain into applying unequivocal domain knowledge into the *classification* (i.e., doing exaclty what you say), as long as it doesn’t update the token scores with such blacklisted e-mail bodies (to avoid aforementioned performance decreases) *and* the blacklisted-to-normal spam messages frequency is low enough that their removal from the process does not decrease significantly the corpus of analyzed messages.

To add (yet) more opinionated guesswork, I’d say that Google products in general tend to lean more towards deriving behavior from large data set analysis rather than gut feeling, so I think it is very unlikely they will consider the suggestion. Would not surprise me, however, if they haven’t already A/B tested that (and every other algorithmic variation under the sun).

But I’ll finish this random rumble with at least one assertive comment: you could do it on your own by creating a blacklist filter – in fact, maybe a browser plugin (or something talking to the API? never looked it to omuch) could trick the spam button into also adding the sender to such a filter. Looks like an interesting hack to try…

A step-by-step guide to configure encrypted Time Machine backups over a non-(Time Capsule) network share

06 Apr 2013

Time Machine is a wonderful piece of software, in no small part for following Mac OS X’s philosophy of simplifying common tasks, but allowing advanced users to go “under the hood”. My issue: I wanted to back up to a hard disk shared by this nice router, and I also wanted encryption.

The best Time Machines are designed in California.

The best Time Machines are designed in California.

Unfortunately, Time Machine won’t do network backups except on Apple Time Capsule, most likely due to its reliance on Unix hard links, which typical Windows (SMB/CIFS)/FAT device based networks (like mine) won’t do. Filesystem-based encryption is also a no-no. And even if that worked, my other devices (such as my XBMC-powered Raspberry Pi) need open access to the files already shared.

Mac OS X sparse images (aka sparse bundles) to the rescue. They are just like the .dmg files you get when downloading Mac software from a website, but supporting all the goodies mentioned above (encryption and hard links) and a bonus: they auto-grow (to a specified limit) as they need more space. Time Machine is capable to use one of those – as long as you can trick it into that, which can be tricky.

I found some great articles online on how to create an sparse image, encrypt it and convince Time Machine to use it, and here is a step-by-step mix of their tips that worked for me:

Step 1: Naming the image

The image file name should contain your computer name and wi-fi address. To ensure that, open your Terminal and paste these commands:

MAC_ADDRESS=`ifconfig en0 | grep ether | awk '{print $2}' | sed 's/://g'`
SHARE_NAME=`scutil --get ComputerName`
IMG_NAME=${SHARE_NAME}_${MAC_ADDRESS}.sparsebundle
echo $IMG_NAME

If you read something like <name>_<hexdigits>.sparsebundle, you are good to go.

Step 2: Creating the image and encrpyting it

Before you paste/type the next block of Terminal voodoo, change the line MAXSIZE=750g to the maximum size you want the sparse image to grow (after that, Time Machine will delete older backups, as usual), .e.g: MAXSIZE=300g. Use the same Terminal window from step 1, as this code depends on the name generated there.

MAXSIZE=750g
hdiutil create -size $MAXSIZE -type SPARSEBUNDLE -nospotlight -volname "Backup of $SHARE_NAME" -fs "Case-sensitive Journaled HFS+" -verbose unencrypted_$IMG_NAME
hdiutil convert -format UDSB -o "$IMG_NAME" -encryption AES-128 "unencrypted_$IMG_NAME"
rm -Rf "unencrypted_$IMG_NAME"

You will be asked for a password (I’d recommend a passphrase, but it’s up to you), and the sparse image file will be on your home folder.

Do not double click/open it yet.

Step 3: Asking Time Machine to play nice

Open Finder and move the image from your home directory to the network share (or copy and delete the original). Now double-click to mount it, enter the password and the “Backup of YourComputerName” should appear on finder. Hooray – except that Time Machine won’t allow you to select it.

We’ll need to force its hand with this last block of commands (yet on that same Terminal window):

defaults write com.apple.systempreferences TMShowUnsupportedNetworkVolumes 1
sudo tmutil setdestination "/Volumes/Backup of $SHARE_NAME"

Enter your Mac user’s password when prompted, and when you open Time Machine preferences, you’ll see “Backup of your_computer_name” configured as the backup volume. As long as it is mounted, it should work with Time Machine just like an USB HD.

Caveat

As with standard Time Machine backups, these can be accessed by any Mac, as long as you have the volume password. I’m not sure, however, whether they can be used for a full restore on a new machine (probably yes if you do the first and third steps, but did not test that far).

Personally, I’m not much of a fan of doing full restore on a different machine/OS version. Although I’ve seen it work, I’d rather start from scratch, copying files from the latest backup of the old computer on a need-to basis. If you think otherwise, this solution may not be the best for you.

UPDATE: This was tested in Mac OS X versions 10.7.5 and 10.8.3. Older versions might work as long as they support encrypted bundles, but I’m not really sure. Let me know on comments below if it does not work for you (and what happened).

Farewell Google Reader; Hello NewsBlur!

21 Mar 2013

NewsBlurAs a content addict, I’ve always sought tools that ease its consumption, from primitive ones such as PointCast, Plucker and Hands to modern-day RSS aggregators like Google Reader.

Reader’s efficient handling of feeds, flexible ordering (a must for webcomics) and read post tracking pretty much killed competition on this arena years ago. But hegemony is seldom a good thing in software, and bad calls like the stubborn push of a GMail-like UI and the abandonment symptoms (recently explained by an ex-PM) made the retirement announce my personal wake-up call to find a better solution.

After evaluating quite a few self-hosted and third-party options, I chose NewsBlur. It’s a well-crafted (mostly by a single developer), open-source and excellent service, with all the bells and whistles Reader had on its best days. It even includes social features, not unlike the ones one that Google axed in favor of paltry Google+ buttons (which are only useful if your target audience is limited to Google employees and Facebook denialists).

It also packs trainable filters to show/hide content (not my turf, but they seem good), and a nice touch for webcomics and sites with partial feeds: you can set up those to display the original content in-place. The iPad app is also neat – a way better proposition than Reader’s (yet more) anemic mobile browser interface.

Due to the massive influx of Reader refugees, it doesn’t offer free accounts right now, but you can play with a simulated account on their homepage and get a good grasp of the real thing. You have to pay for one year upfront, but it’s only $2/month – a small and more than deserved fee for such a lovely piece of work.

Unless, of course, you believe RSS is dead(*). In that case, never mind.

(*) hint: you shouldn’t. Its death is announced so often that it could easily get mistaken for a modern comics character.

Raspberry Pi (with BerryBoot and ChameleonPI)

18 Mar 2013

(TL;DR: if you just want to know how to make ChameleonPI v0.3 work with BerryBoot, jump here)

My Raspberry PI

The Raspberry Pi is a low-priced small computer-in-a-board, built for those who want to tinker, learn and have some geeky fun. The overall experience is quite reminiscent of the hobbyist 8-bit personal computer age – it may be more than a coincidence that the project shares British origins with the Sinclair ZX81/Spectrum and the BBC Micro.

Like many of today’s smartphones and low-power devices, the Pi uses an ARM CPU. This is a fun fact because that architecture was created by Acorn, the very same company that built the original BBC Micro! (the “Model A” and “Model B” boards are a clear pun on the BBC Micro models.)

Here is my Pi, close to an SD card (to get an idea of its size). Yes, it's a full-fledged computer.

Here is my Pi, close to an SD card (to give an idea of its size). Yes, it’s a full-fledged computer.

Like those old computers, you’ll use any TV or monitor (with its HDMI or composite input), and can play around without fear of breaking them, thanks to the absence of moving parts and the low price. But unlike them, you use SD Cards for storage. They are the dream of the 80′s hobbyist: fast and interchangeable like cartridges, reusable and manageable like floppy disks, and as cheap as cassette tapes (you can find a a 16GB Class 10 for less than $15).

Here is a cost breakdown (in CAD): I spent less than $50 on my board (here), and $10 on the case from the photo (although you can get creative and spend more/less). I used HDMI cables and a microUSB charger I had here (minimum is 700mA; I’d suggest at least 1A), but had no keyboard/mouse lying around, so I got this mini keyboard with trackball (which works fine, but is so short-ranged that defeats the purpose of being wireless).

A cheap Wi-Fi dongle got me wireless for another $15. It all depends on what you already have on your house, but you won’t spend more than you would on, say, an Apple TV – which provides a bit more of convenience, but a fraction of the functionality and pretty much none of the DIY fun.

Terrible photo, but a milestone: first boot!

Terrible photo, but a milestone: first boot!

The recommended software to start with is Raspbian, a desktop-like Linux distribution to which you can add anything you want. But several custom-build distros were created for specific applications, like OpenELEC (a powerful XBMC-based media player) and Sugar (containing the educational software that runs on the One-Laptop-Per-Child machines).

But the nerdgasms came with ChameleonPI – a collection of emulators for dozens of old-school platforms. Apple II, MSX, ZX81, Spectrum, C64, Arcades (MAME), GameBoy, NES… you name it, ChameleonPI has it. Just throw your ROMs/DSKs/TAPs (or a willingness to write BASIC code) and have fun!

Swapping cards is easy, but can be cumbersome and waste space, which makes BerryBoot useful: it hosts multiple distros on the same SD Card, showing a (customizable) menu for you to pick them. It also downloads most of the popular ones, straight from the Pi, with a couple of clicks. Linux geeks: it’s like apt, but for distros!

Unfortunatelly BerryBoot does not support ChameleonPI. You can add it manually (following the instructions), but BerryBoot expects a two-partition distro (and only uses the second, as the first one is the always the Raspbian boot partition). ChameleonPI v3 added a third one, allowing non-Linux users to copy ROMs to the SD card.

Since I’d rather use Wi-Fi to copy anyway, I tried to go without it. However, some of the emulators (notoriously LinApple) missed the directory structure – and I also could not write to /roms (the mount point for the partition). Here is what I did:

Steps to add ChameleonPI v0.3 to a BerryBoot SD

  • Download ChameleonPI and follow the instructions to add a custom system (ignoring that you’ll see three lines instead of two on the first step; keep using the second one);

  • Extract ChameleonPI to a separate SD and create a .tar.gz file with the contents of the FAT partition – it’s the one with AUTOEXEC.* files on the root and a lot of directories with old computer names; (alternative: download my copy of the ChameleonPI v3 FAT partition)

  • Save that file to a pen drive/USB stick/external HD;

  • Plug the pen drive on the Raspberry Pi;

  • Boot the SD card with BerryMenu and select ChameleonPI.

  • Press T to open a terminal;

  • Ensure you can write to the /roms directory:

    sudo chown zx /roms
  • Also make sure the mount point for the pen drive is there: (thanks @_47Ronin_ for pointing that out):

    sudo mkdir -p /roms/USB
  • Type exit to return to the ChameleonPI menu, then T again, and check if it mounted the pen drive (otherwise reboot and T again until the command shows some files):

    ls /roms/USB
  • Extract the .tar.gz file there:

    cd /roms
    tar -xvzf /roms/USB/chameleon.v03.fat.partition.tar.gz
  • Reboot again

If everything works, LinApple will allow you to select a disk image pressing F3 (instead of crashing for not having the directory where it expects). You will now also be able to connect via Windows Network to your Pi (use the user zx and password spectrum) and mount the roms folder, not the zx one.

Also be aware that these instructions were tested with ChameleonPI 0.3, not with 0.3.1 (which is giving me a hard time to mount anywhere outside the Pi).

Yes, I brought the Pi to Uken - why not doing turtle graphics alongside Rails?

Yes, I brought the Pi to Uken – why not doing turtle graphics alongside Rails?

Tips and Tricks:

  • You can do the image conversion (the “instructions” of the first step) on the Pi itself – it is way slower than any Linux desktop, but will work if you leave it working during the night as I did – just apt-get the software mentioned

  • XBMC becomes way more useful when you add Fusion (so other plugins can be added via the network)

  • All distros recognized my Wi-Fi dongle on-spot, but configuring the network can be tricky. OpenELEC adds an option with its own name on XBMC, under “System”, but some distros will require you to add your network to wpa_supplicant.conf (BerryBoot has it straight on the setup menu, others will look for it in /etc/wpa_supplicant/).

    In any case, adding a block like this to the existing file should be enough:

    network={
      ssid="your_wifi_network_name"
      psk="your_wifi_password"
    }
  • Make sure you set up the Wi-Fi (or have Ethernet plugged) because the Pi lacks a battery-backed clock, and needs to be online to show and use the correct date/time.

 

Facebook HACK – Toronto

17 Jun 2012

Na minha breve (e ainda não definitiva) passagem por Toronto tive a chance de participar do Facebook HACK – Toronto. Já tinha participado de eventos desse gênero no Brasil (como o RHoK-SP e o Yahoo! Open Hack Day BR), mas essa foi a primeira vez em outro país. E foi bem bacana!

Facebook HACK Toronto 2012 (clique para fotos)

A maior diferença é que no Canadá os caras são organizados: as coisas começam e terminam no horário anunciado. De resto, é tudo igual: camaradagem, troca de informações com uns ajudando os outros, vários times se formando na hora com pessoas que se conhecem ali mesmo, como nos eventos daqui.

O pessoal mandou muito bem nas instalações e na comida (almoço, jantar, comidas de gordo e cerveja no fim do dia à vontade) e as palestras introdutórias foram úteis. À tarde o pessoal mais interessado em business stuff acompanhou palestras em outra sala, e os programadores ficaram no hackaton.

Um ponto negativo é que o evento é de um dia só. Com as palestras e o almoço, só restou o período da tarde para o hackaton em si – bem pouco, em particular quando se está aprendendo novas tecnologias/APIs. O outro revés foi a internet ruim (que não é um “privilégio” dos nossos eventos) fazendo muita gente (como eu) não terminar suas demos em tempo, além de dificultar a vida de quem ia demonstrar.

Pessoal apresentando no Facebook Hack - Toronto

Mas hacking é improviso, e no final o pessoal conseguiu mostrar um monte de aplicativos que, embora em implementações simples, demonstravam conceitos bacanas que podem dar jogo no mundo real. Na minha opinião, esse é o segundo maior objetivo de um hackaton, ficando apenas atrás do aprendizado.

Pra mim o melhor foi poder brincar com coisas novas (Open Graph, Custom Actions, Single Sign-On em mobile) sem a pressão de um projeto “real”. Continuo recomendando esse tipo de evento, e espero continuar participando onde quer que eu esteja – afinal, hackers são hackers em qualquer lugar.

sorteio2600

07 Nov 2011

O sorteio2600 é um programa que eu fiz para o Dev In Vale, por sugestão do Willian Fernandes, um dos organizadores do evento. Já que eu já ia demonstrar o Hello World em um Atari de verdade (graças ao Harmony), e a minha palestra era a última, a idéia era aproveitar o setup e fazer o sorteio dos brindes no próprio Atari.

Pensei que seria uma tarefa fácil, mesmo numa plataforma tão limitada, mas levei umas vinte horas ou mais quebrando a cabeça para que o programa saísse! Este post comenta o processo de desenvolvimento e no final mostra um vídeo do software rodando no Atari. É recomendável ver os slides ou assistir à palestra para entender melhor, mas talvez dê pra acompanhar sem isso.

Harmony: rodando jogos (e testando programas) num Atari de verdade

05 Nov 2011

Cartucho HarmonyA programação para Atari 2600 é uma curiosidade que já me levou a escrever artigo e minstrar palestras sobre o assunto. Vira e mexe estou lendo e experimentando, e até acredito que um dia alguma dessas brincadeiras pode se tornar um jogo de verdade.

Um bom emulador é necessário para programar para qualquer dispositivo, seja ele um celular ou um console. O Atari tem o excelente Stella (cujo debugger é bom até para quem só quer entender como algum jogo funciona). Mas é igualmente importante testar o programa no console “de verdade”, pois só lá os detalhes vão aparecer.

Palestra sobre Programação para Atari 2600 no Dev in Sampa 2011

28 Aug 2011

O Dev in Sampa é um evento bacana, por conta do blend muito equilibrado entre aprendizado e networking. A edição deste ano foi, a meu ver, ainda melhor que a do ano passado – os organizadores (@tinogomes, @nuxlli e @lfcipriani) e o pessoal de apoio da Abril estão de parabéns. Gostei da decisão de reverter ao formato de trilha única de palestras, que limita a quantidade de vagas mas mantém o nível alto e ajuda a galera a se manter na mesma estação.

Clean Code (Código Limpo), por Robert “Uncle Bob” Martin

14 Aug 2011

Já observei que a maior parte dos programadores com algum tempo de estrada tende a se acomodar, acreditando que o que quer que fosse estado da arte (ou apenas popular) quando a pessoa era ultra-jovem é a verdade absoluta e inenarrável. Não sei se por preguiça, insegurança, ou cansaço, mas muita gente, depois de um tempo, se recusa a a aprender qualquer tecnologia, paradigma ou modo de trabalho novo, em muitos casos se afastando da programação porque já “aprendeu tudo”.

My Retweeted Tweets

17 Jul 2011

My Retweeted TweetsEu nunca me animei a colocar o widget do Twitter no blog porque meus tweets variam bastante, e nem todos são interessantes para um público mais amplo. Isso mudou quando ouvi, nos dois últimos minutos do Nerdcast 264, o Rafinha Bastos confessar que:

“Eu (…) deixo no meu twitter só as (…) tweetadas¹ que foram bem retweetadas”

O comentário pode parecer inócuo, mas ajuda a explicar como ele foi considerado tão influente pelo The New York Times – essa “limpeza” garante uma excelente proporção de retweets por tweet na timeline. E o filtro popular deixa quase tudo mais bacana – como qualquer leitor do Digg sabe. Mesmo sem a multidão de seguidores do Rafinha, é possível olhar a própria página de tweets que foram retweetados e conferir a diferença com relação ao “dia-a-dia”.

Infelizmente o widget do Twitter não permite colocar apenas os tweets retweetados. A API de busca também não ajuda, porque só vai até uns poucos dias no passado. O jeito foi colocar a mão na massa e criar o meu próprio widget. Usando o Google AppEngine, a API do Twitter (via Twitter4J) e um final de tarde, saiu o My Retweeted Tweets.

Basta autorizar o aplicativo e ele gera o código que você pode usar para deixar os tweets retweetados em evidência, como eu fiz na coluna lateral do blog (e na ilustração). O código-fonte, como de costume, é livre (Apache License) e está disponível para quem quiser. O aplicativo foi feito para uso próprio, então ainda pode ser bastante melhorado, mas está lá.

¹ Sim, tweetar e seus derivados forçam a amizade, como me lembrou a Bani. Mas é o que a tradução oficial do Twitter diz, então paciência…</p>

miniTruco Android

10 Jul 2011

Clique para baixar o miniTruco AndroidA versão Android do miniTruco está pronta e disponível para download no Android Market. O software é gratuito, e, mais importante: o código-fonte é livre (GPLv3).

miniTruco Android (para leitores de QR Code)O jogo original para Java ME foi criado em 2005, e ainda hoje ultrapassa os 6000 downloads/mês. Publiquei uma versão Android bem instável no final de 2010, e nas últimas semanas dei uma polida nela. Isso só foi possível graças ao feedback através do Market, então continuem sugerindo, criticando e reportando por lá!

A única coisa do miniTruco original que ficou para o futuro foi o multiplayer. Ainda não sei qual tecnologia usar (deve ser Wi-Fi, Bluetooth só me deu dor-de-cabeça), nem o modelo comercial – será que vinga uma colaboração pela versão paga? Por ora vou dar atenção para outros projetos, mas uma hora eu retomo essa parte.

Créditos

**As imagens (logotipo, ícone, baralho, etc.) são de autoria da Bani. A contagem de tentos do truco mineiro (versão 1.1) foi implementada pelo Guilherme Caram. O jogo não seria possível sem os códigos de estratégia do Leonardo Sellani e do Sandro Gasparoto (que também criou o gTruco), além do código do Willian Gigliotti, que não veio para essa versão, mas foi a estratégia original que viabilizou todas as outras.

 

SMS-Denúncia

08 Mar 2011

SMS-Denúncia

Se já é difícil usar o transporte público em condições normais, a situação piora quando tem gente fazendo coisa errada: vândalos, ladrões, vendedores ilegais – isso pra não falar nos malditos chatos com som alto. Por conta disso, a CPTM e o Metrô de São Paulo criaram o SMS-Denúncia: você manda um SMS identificando a ocorrência, o meliante e o local, e os funcionários tomam providências.

O problema é que até você mandar o SMS com todas as informações necessárias o infrator já foi embora. A Bani testemunhou isso acontecendo comigo e programou o SMS-Denúncia para Android – você responde a algumas perguntas com poucos toques na tela do aparelho, e o aplicativo compõe e envia o SMS.

Resolvi dar outro passo e programei o SMS-Denúncia para Java ME, isto é, para celulares que aceitam aplicativos Java (possivelmente a maioria dos aparelhos em atividade nos trens). Você pode instalar pelo navegador do celular – basta abrir o endereço http://chester.me/smsdenuncia/SMS-Denuncia.jad, ou baixar no computador e transferir para o aparelho, usando este link para o arquivo .jar.

Os dois aplicativos são software livre (licença MIT), e o código-fonte está no github. Use com responsabilidade e ajude a fazer o Metrô e a CPTM melhores para todos os usuários!

Revolution in the Valley: The Insanely Great Story of How the Mac Was Made

18 Jan 2011

Antes de se tornar objeto da admiração de uns e desinteresse/suspeita de outros, a Apple passou por três fases bem definidas: a “era de ouro” em que o Apple II e o Macintosh original foram criados; a queda em parafuso rumo à irrelevância; e a volta por cima. O papel evidente de Steve Jobs nas fases virtuosas alavanca o culto em torno de sua pessoa  a um ponto que fica difícil separar a verdade do mito, valorizando qualquer testemunho de quem esteve mais próximo.

Revolution in the Valley: The Insanely Great Story of How the Mac Was Made é um livro que reúne dúzias de histórias sobre o fim da primeira fase, isto é, sobre a criação do Macintosh. Boa parte delas veio do site Folklore.org: Macintosh Stories, organizado pelo autor – ninguém menos que Andy Hertzfeld, que escreveu boa parte do sistema operacional original do Mac.

Racing the Beam: Um raio-x do Atari 2600

04 Jan 2011

Racing The BeamUm aviso: não tenho como ser muito imparcial com este livro. Pra começo de conversa, jogos como Enduro, Pitfall, Adventure e Raiders of The Lost Ark são parte integrante das minhas memórias de infância. Eu associo o nome Atari ao universo dos videogames tanto quanto gerações mais recentes o fazem com Nintendo, Sega ou Sony. E um dos grandes “to-do”s da minha vida é concluir o desenvolvimento de algum jogo para essa plataforma. Já flertei com esta proeza no passado, o que resultou em uma pequena animação interativa (perdida no tempo) e em um artigo publicado há quase DEZ anos atrás no site Fliperama – cortesia do Internet Archive Wayback Machine.

Coding Dojo no Apontador

14 Nov 2010

O Encontro Ágil 2010 (que merecia seu próprio post) se destacou pelo face-to-face: os open spaces e interações entre participantes foram tão produtivos que a tradicional carência de conectividade sem fio da USP trabalhou a favor. E foi justamente uma dessas interações, o Coding Dojo (saiba o que é um) organizado pelo Bruno Gola (com o forte apoio do Asa) que me inspirou a organizar uma sessão equivalente no Apontador. Segue uma visão geral da experiência:

Preparação

Devido à heterogeneidade do público potencial (e também para levar o ambiente já preparado), era razoável escolher a linguagem com antecedência. Usamos Python por tres motivos: é fácil de aprender na hora para quem nunca viu, o código fica compacto e legível, e a expoisção a uma linguagem nova é um bônus extra (de fato, um dos pontos positivos mais enfatizados na retrospectiva).

A estação de trabalho era o meu Mac do trabalho mesmo, então usei o TextWrangler, um editor básico com sintaxe colorida e que permite alternar facilmente entre o programa e o teste. Deixamos o editor ocupando 2/3 da tela, e o restante dividido entre o console (posicionado estrategicamente para garantir a visibilidade do OK ou FAILED do teste) e o cronômetro – ter as duas coisas na tela dá mais segurança e tranquilidade à dupla.

Uma reprodução do jeitão da tela durante o Dojo no Apontador (clique para ampliar)

Eu queria um cronômetro offline – apesar da internet do Apontador ser boa, é sempre bom reduzir riscos. Adorei o Coding Dojo Screenlet, escrito pelo próprio Gola, cuja cor de fundo (vermelho/verde) reflete o status do teste, ajudando a audiência saber quando (não) é apropriado se manifestar, mas ele só existe para Linux. A solução foi o timer do Hora Agora (criado pela Bani), que, aliado à interface minimalista do Chrome, resolveu super bem: o alarme ininterrupto garantia que o piloto, ao sentar no teclado, não esquecesse de reiniciar o timer (usando o parâmetro “?t=05:00″, era só dar reload na página).

Num dojo (e em TDD no geral) é uma boa idéia que, quando viável, o teste seja executado automaticamente sempre que você salva o arquivo. Conseguimos isso graças ao uso de nose + tdaemon (que ainda dá o resultado em popups do Growl), mas tem outras alternativas por aí como o autotest e o watchr. Outra idéia é rodar todo o ambiente do Dojo online, usando o CyberDojo. Opções não faltam: escolha conforme a linguagem, ambiente e gosto – o importante é deixar tudo preparado antes de começar!

No Dia

Após uma rápida introdução ao conceito de dojo e às “regras do jogo” (a Karen recomenda esses dois resumos), compilamos no quadro uma lista ordenada dos participantes – o que evita confusão na hora de trocar a dupla. A lista foi pela ordem em que as pessoas se voluntariaram, mas acho válida também a sugestão do Gola de alternar entre pessoas mais e menos familiarizadas com a tecnologia.

Dojo era novidade para quase todos os presentes, então pareceu razoável começar com um problema introdutório (RandoriKata), e fizemos o RomanNumbers (não por acaso, o mesmo que foi feito no Encontro Ágil). Foi interessante ver como a dinâmica e a técnica de solução de um mesmo problema variam em dojos diferentes.

Conclusão

A retrospectiva foi parte importante da experiência – ajudou a medir o que aprendemos juntos, onde acertamos e onde poderíamos melhorar. E me chamou a atenção ver que, mesmo não sendo o objetivo principal do dojo resolver o problema em si, o pessoal não quis ir pra casa sem ver todos os testes funcionarem. Não tenho dúvidas sobre o impacto positivo que isso terá no dia-a-dia de cada um.

Organizar um dojo não é coisa de outro mundo (gastei mais tempo escrevendo esse post do que preparando) – só é preciso realmente ter um espaço com projetor, comida e interessados. Recomendo reservar entre 1h30 e 2h para a brincadeira, e levar o ambiente pronto, deixando o encontro focado em programar e interagir.

Abrace a simplicidade e ajude as pessoas a seguirem as regras, mas sem pressão. Não perca de vista o aspecto lúdico e não-competitivo do evento, e o resto sai por conta. O pessoal se animou a compartilhar o código e marcar os próximos logo de cara. E o Apontador está considerando promover **dojos abertos para visitantes – interessados, manifestem-se! **

Google Developer Day 2010

01 Nov 2010

GDD2010-logoA maratona de eventos do mês foi concluída com a edição deste ano do Google Developer Day em São Paulo. É um evento bastante concorrido (afinal, é gratuito, bom e ligado ao Google), o que deve tornar a escolha dos participantes um desafio interessante – mesmo para aqueles cuja missão já é meio que organizar/classificar o universo…

Esse ano o processo de inscrição incluiu uma provinha que gerou bastante “mimimi” nas listas e redes sociais: uns questionaram a eficácia de um teste tão básico (e para esses recomendo ler sobre FizzBuzz e programadores que não programam), outros se sentiram injustiçados com a eventual não-convocação. O fato e que ela ajudou: qualquer pessoa que você encontrasse lá esse ano era, em maior ou menor grau, apaixonada por código. Não era bem assim em anos anteriores, e isso fez diferença no café/happy hour. Sabem como é: developers, developers, developers!

A organização também melhorou em todos os aspectos: da alimentação (que já era boa) aos os brindes (incluindo uma camiseta bem bacana) e internet, tudo pareceu funcionar melhor. Tinha mais gente que nos outros anos, e o pessoal xingou muito no twitter esse aspecto. Pessoalmente, achei que acomodaram bem – e que o GDD escala.

O conteúdo era, como se esperava, um grande showcase de tecnologias Google. Como recém-convertido a Android (e vindo do ADL Bootcamp), fiquei empolgado com a ênfase dada à plataforma – que não sucumbiu à miopia das operadoras, como eu temia no meu primeiro contato, em 2007. De qualquer forma, com três palestras simultâneas divididas em quatro trilhas (Android, Cloud, APIs e Chrome/HTML5), era difícil achar um horário em que nada interessasse (só deixei de ver dois blocos, para fins de socialização e uma merecida soneca nos pufes).

As palestras eram mais abrangentes que profundas (ao menos as que eu vi) – o que, para autodidatas, é um fantástico “mapa da mina” sobre o que explorar no universo de tecnologias que o Google disponibiliza. Em particular gostei de ver novamente o p@ falando sobre AppEngine e outros tópicos, e o Ryan Boyd destrinchando OAuth e OpenID. O que deu menos certo, a meu ver, foi a participação de empresas que usam as APIs do Google: a intenção de levar “gente que faz” para mostrar seus cases foi boa, mas rolou desde constrangimento de ex-funcionário até palestra tomada pelo “jabá”.

Mas essas coisas acontecem, e nem de longe tiram o brilho do evento. Pelo contrário, esse mesmo espírito de abertura conduziu ao fechamento do evento com apresentação dos GTUGs (Google Technology User Groups) do Brasil (onde o Paulo Fernandes do SP-GTUG sorteou vários brindes) e ao happy hour, no qual Googlers e civis papearam bastante. Em resumo, o casamento entre tecnologia e fator humano tornou o evento um sucesso, que espero ver novamente em 2011.

RubyConf Brasil 2010

31 Oct 2010

Logo RubyConf 2010Um complemento bacana a participar da PythonBrasil foi estar na RubyConf Brasil 2010. O evento sucede os Rails Summit, e na mesma tradição desses tem a LocaWeb como organizador, mas com empresas como a Gonow (onde o Akita, pioneiro do Rails no Brasil, trabalha atualmente) e a Caelum (que vem expandindo sua posição já consolidada no mundo Java para os novos fronts do desenvolvimento) aparecendo em destaque.

Apesar da internet ter deixado a desejar (em particular no primeiro dia), o evento contou com estrutura ótima: comeu-se bem (não teve almoço, mas estávamos sobre um shopping center), o espaço foi suficiente (não tão grande quanto o dos anteriores, segundo os veteranos, mas coube todo mundo) e o local era de facílimo acesso.

As palestras focaram muito em aplicação das tecnologias que se consolidaram no mundo do Ruby nos últimos tempos. Eu, que andava um pouco afastado da tecnologia, curti muito a abordagem. Houve um espaço para “desconferências”, que funcionaram bem, mas eram um pouco formais demais, talvez desestimulando quem tivesse um recado mais curto para passar.

Como sempre, o lado social é importante. Houve um happy hour no Bar Opção (no qual fiquei pouco tempo, o cansaço dos eventos anteriores já se acumulava) e a impressão que ficou ao conversar com as pessoas é que as empresas estão ficando mais receptivas ao uso de linguagens dinâmicas – possivelmente um movimento em sintonia com a crescente adoção de práticas ágeis na gestão do desenvolvimento de software.

Toda essa vibração em torno de Ruby on Rails me faz ver que é questão de tempo até que apareçam as primeiras aplicações Ruby on Rails usando a Apontador API. Ela ainda não dispõe de biblioteca oficial para esse ambiente, mas com módulos como RestClient e oauth-plugin, creio que os rubistas não terão grandes dificuldades (e se estiverem, estamos lá para ajudar).

Android Developer Lab Bootcamp

31 Oct 2010

Karen e Lucas ganhando o Lego MindstormsQuase como um “esquenta” para o GDD, o Google marcou na véspera (e no mesmo local) o Android Developer Lab Bootcamp, cuja proposta foi ocupar metade do dia com um “bootstrap” da tecnologia, no qual desenvolvedores participaram de:

  • Uma apresentação rápida sobre Android (na qual ganhei um bonequinho de vinil respondendo a uma pergunta);
  • Uma demonstração na qual cada participante reproduziu¹ em seu micro o passo-a-passo da construção de um aplicativo;
  • Um desafio: adicionar um feature ao aplicativo em um intervalo de tempo reduzido. Os poucos que conseguiram ganharam camisetas, e participaram do sorteio de um Lego Mindstorms.

¹ O método utilizado foi uma aplicativo template, no qual o código dos features era “des-comentado” a cada passo (procure por “Step 0″). Parece bobo, mas na prática essa técnica alia o hands-on com a agilidade de algo pronto – gostei.

Uma pequena confusão foi causada pelo fato de o site do evento pedir para baixar as ferramentas, mas não para instalar as mesmas previamente. Algumas pessoas mal conseguiram concluir a configuração do ambiente, outras tantas perderam momentos preciosos da apresentação nesse processo de configuração. Mas no final deu tudo certo, e eu, recém-convertido ao Android, já estou com idéias envolvendo a migração de antigos projetos J2ME para a nova plataforma…

Bonequinho do Android que eu ganheiDesagradável mesmo foi o gaiato que se aproveitou do surgimento do FireSheep (que permite a pessoas sem conhecimento técnico capturar cookies de autenticação de sites como o Twitter) e da ausência de criptografia da rede Wi-Fi do evento (não que só isso seja garantia de segurança total, mas a falta dela viabiliza a coisa). Eu normalmente sou paranóico quando estou em redes públicas, mas acreditava que num evento desses o pessoal estaria mais focado em programar do que em brincar de “ráquer”. De qualquer forma, o Sheepsafe parece uma alternativa bacana para heavy users de redes públicas minimizarem esse tipo de inconveniente.

Finalmente, vale mencionar que quem ganhou o prêmio foi uma dupla, composta pelos meus amigos na foto: Lucas Uyezu e Karen Zamlutti – esta última também colega de IME/USP e integrante do time do Apontador. Detalhe: eles mal se conheciam, e trabalharam em par por iniciativa e inclinação natural a metodologias ágeis. Fica a lição.

Participando (e palestrando) na PythonBrasil[6]

26 Oct 2010

Estive na PythonBrasil[6], isto é, no “6º Encontro Brasileiro da Comunidade Python”, que rolou em Curitiba entre 21 e 23 de Outubro. Por conta da aula na UNESP, só pude chegar na sexta (22), mas ainda assim deu pra aproveitar bastante.

Alguém tuitou que este foi um encontro orientado a pessoas, e é verdade: todos lá estavam muito acessíveis – sem deixar de lado o perfeccionismo e profundidade no conteúdo, os palestrantes estabeleceram um diálogo muito positvo com todos os presentes, dentro e fora das palestras.

Uma das marcas da comunidade Python é receber bem todos os interessados, e este aspecto foi contemplado pela ilustre presença do Fabio Akita (@AkitaOnRails), que, à exemplo do que fez no QCon, mostrou onde a comunidade Ruby/Rails acertou e errou ao longo dos anos, deixando lições inestimáveis para os pythonistas que souberam enxergar além das diferenças.

Outro destaque foi o Pedro Valente (@pedrovalente), o elo perdido entre o jornalismo e o desenvolvimento de software. Ele agitou o #freecep nos open spaces e apresentou a versão python-ativada da sua consagrada exposição sobre extração de dados públicos “na marra” – que deixava uma dica para que eu fizesse (mais) uma lightning talk sobre o Cruzalinhas.

Eu achava que o assunto já tinha sido abordado o suficiente (falei dele no FISL 11 e no QCon), mas dado que a palestra original do Pedro Valente foi justamente o que me inspirou a criar o site, achei que não faria mal em complementar a apresentação dele (mesmo sem ter ensaiado ou feito slides próprios para a ocasião). Mas ver o pessoal abraçando à idéia de que serviços públicos implicam em dados públicos já valeu: o @botobr está tentando reproduzir o lance em Curitiba, o @jbochi abriu o fonte do Tô a Pé, entre outros.

De qualquer forma, eu estava no evento como palestrante: fui falar da Apontador API, a iniciativa do Apontador em abrir suas APIs (um assunto que merece seu próprio post, a seu tempo). Fiquei muito satisfeito com a resposta do público: não foram passivos, fazendo perguntas contundentes (acerca da qualidade, da relevância e do posicionamento do produto diante de alternativas) e dando sugestões muito coerentes (que já dispararam ações lá dentro). Audiência qualificada é tudo!

Os slides estão disponíveis no SlideShare (e abaixo), e incluem incluem exemplos básicos de uso da biblioteca Python (cujo código-fonte é livre e também pode ser obtido no github). Ficam os meus agradecimentos à organização pela oportunidade, ao público pela receptividade e a todos os participantes por um excelente evento!

Aula sobre Mashups Web na UNESP (SECCOMP 2010)

24 Oct 2010

Um prédio do Campus (fonte: site UNESP)A organização da XVIII Semana da Ciência da Computação (SECCOMP 2010) me convidou, por intermédio do Eduardo Maçan (o Kevin Bacon do software livre: todo mundo no meio o conhece), a ministrar uma aula (mini-curso) sobre mashups web para os alunos de Ciências da Computação no último dia 21.

Por se tratar de um tema pouco convencional, optei por uma abordagem mais descontraída: as origens musicais do tema foram ilustradas com um videoclip de música do Girl Talk e os exemplos iam de sites comerciais como o BuscaPé e o surreal Mobzombies.

Este panorama foi complementado por um passeio através de diversas tecnologias relevantes para quem quer integrar e misturar as fontes de dados e APIs existentes na web. A apresentação desta parte teórica (com links úteis no final, incluindo o ensaio que foi a base principal da aula) está disponível no SlideShare.

A prática foi feita em duas partes: um exercício usando o excelente Yahoo! Pipes para mesclar diferentes fontes de informação; e uma brincadeira simples, mas completa, na qual os alunos usaram a Apontador API para encontrar bares próximos à universidade e apresentá-los em uma página usando a API do Google Maps.

Foi uma experiência gratificante, na qual espero ter ajudado a mostrar para o pessoal que está chegando agora a importância da programação baseada no ecossistema Web 2.0, deixando um “hello world” sobre o qual eles possam criar coisas interessantes.

JavaScript: The Good Parts (O Melhor do JavaScript)

27 Sep 2010

Douglas Crockford, autor de JavaScript: The Good PartsNão ia escrever sobre esse livro, simplesmente porque não teria muito a acrescentar, mas o Lucas me convenceu de que valeria a pena nem que fosse só pra convocar as pessoas a ler. Se você programa em JavaScript (mais ainda: se não programa ou não gosta dela por ter tido experiências ruins), preste atenção:

QCon São Paulo 2010

12 Sep 2010

QCon SP 2010O InfoQ é referência em notícias e informações sobre desenvolvimento de software corporativo, cuja versão nacional abriu caminho para viabilizar a primeira edição do QCon (evento popular promovido pelo site) na América Latina. Estou falando do QCon São Paulo 2010, organizado pela Caelum neste final-de-semana, ao qual tive a oportunidade de comparecer.

Pode parecer loucura gastar uma boa grana para passar o sábado e o domingo em um evento desse gênero, mas afirmo que vale a pena. A oportunidade de ver o Douglas Crockford (autoridade em JavaScript cujo livro merece seu próprio post) já valeria o esforço, mas não ficou só nisso: os keynotes e palestras no geral foram bons, o coffee break estava ótimo, enfim, tudo nos conformes. Apenas o WiFi deixou a desejar, limitando a possibilidade de falar sobre ele no Twitter.

A organização introduziu as palestras-relâmpago, que já estão se tornando tradicionais em eventos do gênero. Mas resolveram ir além, adotando um formato semelhante ao Ignite – as apresentações de 5 minutos têm que ter exatamente 15 slides, que avançam automaticamente a cada 20 segundos. Pode parecer um detalhe, mas isso torna a preparação das palestras um pouco mais complexa.

Apanhei para adaptar a palestra sobre o cruzalinhas (que eu já tinha apresentado no FISL 11 e no TDC 2010) a esse esquema, mas o resultado não desagradou. A Bani também teve que sambar para adaptar a aula/palestra/BoF dela sobre Licenças de Software Livre, mas sintetizou muito conteúdo (PDF) em 5 minutos. Detalhe: ela queria um relógio para contar o tempo, mas a falta de internet não deixava usar nenhuma das alternativas disponíveis. Aí a gente hackeou um “reloginho” em JavaScript minutos antes de começarem os lightning talks – olhando em retrospectiva, eu devia era ter falado disso nos meus 5 minutos. :-P

No final deu tudo certo, e o evento foi fantástico. Os brindes foram um show à parte: camiseta e bonequinho do evento, ioiô do PagSeguro, caneta bacanuda da Oracle, cupcake da Cupcakeria, estojo de post-its e bloquinho da Globo.Com e M&Ms da IBM. Dessa última a Bani ainda ganhou um iPod Touch (é, a gente atrai eles :-) ) escrevendo uma frase gigante sobre Gestão Colaborativa do Ciclo de Vida da Aplicação!

Os participantes foram o melhor: dos veteranos de eventos do gênero a vários outros que conheci por lá, rendeu conversas interessantes como poucos eventos corporativos. O consenso era que ter rolado num fim-de-semana meio que selecionou participantes que realmente gostam do que fazem. Recomendo participar das próximas edições (eu pretendo fazê-lo), onde quer que aconteçam.

Dev in Sampa 2010

16 Aug 2010

Logo do Dev in SampaDe início eu nem ia escrever sobre o Dev in Sampa (que rolou no último sábado), já que os organizadores são brothers e temia pela subjetivdade de um post. Mas lá eu percebi que esse clima de “intimidade” é o diferencial do evento (mesmo pra quem chegou sem conhecer ninguém) – perdi mais de uma palestra em prol de conversas muito bacanas com os desenvolvedores mais rúts dos intertubes.

A atmosfera descontraída não deve ser confundida com amadorismo, muito pelo contrário: além de coffee breaks muito bem servidos, o evento permitiu almoçar no sempre vencedor refeitório da Abril. O WiFi não funcionou pra todo mundo, mas o pessoal foi dando um jeito. As palestras enfrentaram o desafio de atender a um público bastante variado em termos de nível e tipo de experiência, mas no geral conseguiram agradar a gregos e troianos.

Uma das mais surreais foi a palestra-peça-de-teatro “Por que eu sou fanático por testes e você é um bundão” – uma maneira lúdica que o pessoal da HeLabs encontrou de chamar a atenção para a importância da aplicação de boas práticas (em particular, TDD) no dia-a-dia do desenvolvimento de software. Como de costume em qualquer evento com participação da audiência, fui escalado para passar vergonha lá na frente :-) mas valeu, ainda mais pelo papo com o Sylvestre depois do final.

Enfim, um evento que misturou bem a parte didática/técnica com o networking “do bem”. Espero ver outros assim.

FISL 11, cruzalinhas e iG Code Golf

25 Jul 2010

A edição desse ano do Fórum Internacional Software Livre foi interessante como de costume: palestrantes de renome e a troca de experiências dentro e fora do evento com as pessoas que fazem o software livre acontecer seguramente justificam passar esses dias em Porto Alegre. Esse ano fiz dois lances bacanas por lá:

O primeiro foi preparar e apresentar uma palestra-relâmpago sobre o cruzalinhas (slides aqui, vídeo em breve). Resolvi fazer isso na última hora, e me surpreendi com o interesse de pessoas de outras cidades (Manaus, Campinas, Florianópolis e da própria Porto Alegre) em fazer a mesma coisa, já que, segundo esse pessoal, a dificuldade em obter informações sobre o transporte público é a mesma.

O outro foi participar do Code Golf do iG, uma proposta inusitada, na qual são apresentados cinco problemas de programação. Eles são relativamente simples – o desafio é escrever o menor código-fonte que resolva cada um.

Claro que um código Python é bem menor que o seu equivalente Java, e por isso haviam categorias isoladas para cada linguagem suportada (Perl, Python, PHP, Java e Ruby). Fui o vencedor da categoria Java, com os códigos que estão no final do post.

Um aviso: NUNCA escreva código assim, a não ser que esteja participando de um Code Golf. O objetivo era sempre reduzir o tamanho e compensar a proibição de imports explícitos. Isso tem um custo: a performance quase sempre é horrível, a legibilidade é zero, é quase impossível modificar. Senti esse último lance na prática: tive que fazer uma gambiarra na questão 4 (o formato da entrada mudou, e o fix apropriado implicaria em reescrever tudo) – o tamanho dobrou e fui penalizado por isso.


Minhas soluções para o Code Golf (enunciados aqui)

Problema 1:

public class c{public static void main(String x[])throws Exception{int a=,b=1,c,i;for(i=Integer.parseInt(x[]);i>;i--){System.out.print(b+(i==1?"":", "));b=b+a;a=b-a;}}}

Problema 2:

public class c{public static void main(String x[]) throws Exception{char m,s[]=x[].replace(" ","").toLowerCase().toCharArray(),i=;int f[]=new int[255],c,l=s.length;boolean p=true;for(;i<l;i++){p=p&&s[i]==s[l-i-1];f[s[i]]++;}System.out.println((p?"":"Não é ")+"Palíndrome");while(true){m=;for(i=;i<255;i++){m=f[m]>f[i]?m:i;}if(f[m]==)return;System.out.println(f[m]+" "+m);f[m]=;}}}

Problema 3:

public class c{public static void main(String x[]) throws Exception{long a=,m=,b,c,F=0xFFFFFFFF;int i,j=;for(;j<2;j++){c=;for(i=;i<4;i++)c=c*256+Integer.parseInt(x[j].split("\\.")[i]);a=m;m=c;}a=a|(F-m);b=32;for(c=0xFF000000l;c>;c/=256){System.out.print(((a&c)>>(b-=8))+(b==?" /":"."));}for(b=32;(m&1)==;m/=2)b--;System.out.print(b);}}

Problema 4:

public class c{static int h=-1;static void w(int i){if(h!=i)System.out.print(i+" ");h=i;}public static void main(String y[])throws Exception{String[]x=(y[]+",-,"+y[1]).split(",");int m,l=x.length,n[]=new int[l],p=,i=,a=;for(;i<l;i++)if(x[i].equals("-")){a=i;p=i+1;}else n[i]=Integer.parseInt(x[i]);for(i=;(i<a&&p<l);){if(n[i]<n[p]){m=n[i];i++;}else{m=n[p];p++;}w(m);}for(;i<a;i++)w(n[i]);for(;p<l;p++)w(n[p]);}}

Problema 5:

public class c{public static void main(String x[])throws Exception{int c,p,t=,v[]={1,3,3,5,10,50};while((c=System.in.read())>-1){p=("pcbtar".indexOf(c));t+=p>-1?v[p]:;}System.out.print(t);}}

Coders At Work (Peter Seibel)

14 Jul 2010

Coders At Work, Peter SeibelDepois de ter curtido tanto as entrevistas com os fundadores das startups mais famosas no Founders At Work, eu esperava que o Coders at Work – fosse ser ainda mais bacana. Afinal, a lista de entrevistados é diversificada e impressionante: vai de gente mais “próxima” como os criadores do memcached, JavaScript e JSON até decanos como Fran Allen e Donald Knuth, cujos méritos acadêmicos e na indústria tornam desnecessárias quaisquer apresentações.

tilewriter – desenhando ladrilhos em JavaScript

20 Jun 2010

Eu fiquei vidrado no layout de “ladrinhos” do logotipo do site do RHoK, que lembra os micros de 8 bits sem deixar de ser moderno, e pensei “taí, vou roubar me inspirar criar um trabalho artístico derivativo para o próximo update visual do meu blog”.

O chato é que não apenas sou um zero à esquerda em GIMP/PhotoShop, mas também queria algo que pesasse menos no carregamento. Solução: programar.

O canvas do HTML5 viria a calhar, mas o suporte dos browsers ainda está longe do ideal. Resolvi, então, criar uma biblioteca minimalista para fazer desenhos nesse estilo usando elementos de HTML.

Urban Fact (Fato Urbano) / RHoK #1 SP

07 Jun 2010

O Random Hacks of Kindness (RHoK) reuniu programadores em vários locais do mundo simultaneamente ao longo do último fim-de-semana, com o objetivo de desenvolver ferramentas que possam ajudar a lidar com os desafios gerados pelo risco de desastres naturais.

O esforço foi patrocinado e liderado por gente do Google, Yahoo!, Microsoft, NASA e do Banco Mundial, e eu não só tive a oportunidade de participar da primeira edição de São Paulo, que aconteceu aqui na Fundação Getúlio Vargas (FGV), mas também tive a alegria de ter o projeto do meu grupo, o Urban Fact, premiado com o segundo lugar.

cruzalinhas

04 Jun 2010

O site da SPTrans oferece várias informações sobre as linhas de ônibus, trem e metrô que operam na cidade de São Paulo. A navegação, entretanto, deixa um pouco a desejar – razão que leva as pessoas a alternativas como o Tô a Pé e o eficiente sistema de rotas do Google Maps.

Este último resolve bem a minha vida, mas às vezes tudo o que eu quero é saber quais ônibus passam por um determinado local. Ou ainda: quais, dentre eles, passam por um segundo local, e quais passam entre este e um terceiro, i.e., quais minhas opções para ir do ponto A ao ponto B, e dele ao ponto C, e por aí em diante.

Misturando essa demanda com um desejo de colocar as informações de itinerário do transporte público de São Paulo nas mãos da população, desenvolvi o cruzalinhas. A aplicação ainda precisa de muitas melhorias (eu diria que é “beta”, mas o que não é?) mas já permite responder às perguntas acima.

Como de costume, o código-fonte é livre (licença MIT), e esse post vai falar um pouco sobre o funcionamento do mesmo.

cruzalinhas

HOWTO: Python 2.6.5 + Django (via Passenger WSGI) at DreamHost

08 Apr 2010

djangoDreamhost is a pretty decent provider for people with lots of small websites. I didn’t expect them to have, say, Python 3 (although I’d love to), but I was surprised to find their official support is just for 2.4!

There are instructions for custom builds, but they are not much supportive (“If you are positive that you need to install Python, reconsider”), and a few unofficial ones. Here are the steps I used – try them at your own risk, since I can’t give any guarantees other than the fact that they worked for me (hint: create a new subdomain with its own user and try that there first.)

(These instructions might also work for Python 3.0 – just replace the version numbers accordingly. I did not test that (yet), but if you do, please let me know.)

u.nu URL shortener bookmarklet

05 Feb 2010

Unfortunately, u.nu ceased to exist as an URL shortener,
but I decided to keep the article as a curiosity.

A URL shortener like TinyURL or bit.ly is a handy tool on these Twitter times. But even shortened URLs from those services can get a bit too long when you are on tight spots.

Enter u.nu, arguably the shortest URL shortener in town – which, unfortunately, does not come with a one-click shortening option like bit.ly’s bookmarklet. It does, however, offer an API, with which I quickly hacked a minimalistic bookmarklet.

Just drag and drop the link below to your browser and turn anything in your browser into a short URL with a single click:

<a href="javascript:location.href="'http://u.nu/unu-api-simple?url='+escape(location.href);"" id="a_unu">u.nu</a> <- drag that to your browser’s toolbar.

UPDATE: Real stupid mistake – forgot to escape the URL (but hey, I told it was a quick hack :-P ) – fixed now (Feb 9, 2010).

Plataforma Vivo para desenvolvimento e comercialização de aplicativos baseados em SMS – será a App Store tupiniquim?

27 Jan 2010

Show me the money!Parece que ontem a operadora de telefonia móvel Vivo apresentou no Campus Party sua plataforma de desenvolvimento de aplicativos para celulares – apresentação que infelizmente eu perdi por causa de trabalho e tchuva.

A notícia (TI Inside) me deixou salivando: potencialmente a coisa permitiria publicar apps sem o envolvimento de terceiros (como na App Store), mas cobrando direto na conta telefônica – só isso já merece alguma consideração.

O processo começa com a abertura de um cadastro e leitura da documentação das APIs – que são chamadas externamente (ou seja, seu aplicativo não roda no celular, e sim no seu próprio servidor), e consistem no envio de SMS, MMS e WAP Push (que é, grosso modo, o envio de um link para um conteúdo WAP) através de uma API REST (que cheira a SOAP com uma capinha REST por cima, apesar de contar com conversão implícita de JSON), com bibliotecas prontas para PHP, Java e .Net – mas, claro sendo REST, qualquer linguagem vale.

Pode parecer pobre em comparação, digamos, com apps iPhone, mas aplicações baseadas em SMS rodam até mesmo nos celulares mais modestos – eu lembro que, quando vi um pager pela primeira vez, minha primeira reação foi “cara, eu muito faria um adventure de texto rolando nessa parada”. De repente um miniTruco baseado em SMS… idéias mil.

Dei uma olhada na biblioteca Java. Ela é empacotada de maneira, digamos, pouco carinhosa (ex.: inclui o Jakarta Commons HttpClient como código-fonte, misturado com o código da API – provavelmente foi gerada por alguma ferramenta) e abre com um caminhão de issues no Eclipse. O mérito é que vem com uns exemplos (bem básicos) de uso, e os issues devem ser coisa fácil de resolver (depois eu vejo com calma).

Juntando o fato de as APIs só rolarem atualmente num sandbox com a quantidade de “em breve” no site, a primeira leitura é que o produto ainda está bem em construção – o link “modelo de negócio” ser um Flash com quatro slides explica muito sobre o estágio embrionário da empreitada enquanto produto. Dá pra encarar como risco (i.e., será que a plataforma vai pro ar?) ou como oportunidade (dá tempo de desenvolver algo e sair na frente).

E ficam no ar duas grandes dúvidas:

  • As APIs só falam (numa leitura superficial que fiz até agora) em envio de mensagens. E o recebimento? A coisa só pode ser considerada uma aplicação autônoma se o usuário puder enviar SMS de volta, e não achei nenhuma API para que a app consiga receber respostas. Será que a idéia é fazer WAP Push, mandar o cara para o meu site e lá ele interagir para receber o próximo SMS?

  • Quanto isso custa pro usuário? O artigo fala em porcentagens sobre o tráfego gerado, mas não diz quanto o usuário do aplicativo vai pagar por esse tráfego (se for preço normal de SMS, esquece – sai mais barato comprar um netbook pra jogar o adventure de texto :-P). E ainda fala em venda dos aplicativos, o que também é complicado: se o cara tiver que pagar pra baixar e pagar pra usar, só vai dar certo em um país onde as pessoas sejam conformistas a ponto de pagar imposto várias vezes sobre o mesmo produto… ah, tá, entendi.

Espero que as pessoas que foram à apresentação tenhma perguntado essas coisas e postem em algum lugar em breve. Também devo perguntar no fórum e ver no que dá. Eu sou sempre reticente com qualquer associação com operadoras de celular, mas numa primeira análise essa plataforma (quando e se ficar pronta) parece menos evil do que de costume. Vamos ver.

A linguagem mais importante para um programador

16 Nov 2009

Fiz o comentário no Twitter, mas o ponto é tão importante que vale a pena estender aqui: na semana passada dei uma entrevista no programa Olhar Digital, e surgiu a pergunta que aspirantes e programadores iniciantes sempre me fazem: “qual a primeira/próxima linguagem que eu devo aprender?”

Os veteranos costumam responder a essa pergunta vendendo suas linguagens prediletas em detrimento de outras, usando argumentos como tipagem, clareza, simplicidade, performance e tantos outros que nem sempre são tão objetivos quanto aparentam.

No entanto, a resposta que eu costumo dar (e que, por distração, não usei no programa) é “inglês”.

O idioma de Shakespeare é indispensável.Pode parecer que falo isso porque trabalho com muitas empresas/pessoas de fora, mas não é verdade: o campo está em constante atualização, e as novidades relevantes quase sempre começam neste idioma, independente do país de origem.

Não ler inglês é ter que esperar pelas traduções; não escrever inglês é não participar. Pouco importa se você quer colaborar ou apenas consultar, os assuntos mais “enroscados” vão exigir alguma familiaridade com este idioma.

Sim, existem muitos livros traduzidos. Eu mesmo uso bastante (o custo e disponibilidade são um fator importante), mas a qualidade da tradução varia a ponto de tornar algumas passagens ininteligíveis para quem não tem como deduzir a intenção do autor.

Não estou falando (só) daqueles falsos cognatos que fazem doer a vista – um problema comum é a tradução livre de termos técnicos e expressões para formas que ninguém usa, muitas vezes a ponto de tornar a frase incompreensível – se eu dissesse que trabalho com logiciário, pouca gente ia se animar a falar de tecnologia comigo.

Resumindo, galera: antes de entrar nos ponteiros e closures, vamos para o básico: I am, you are, he is

MemeThis

05 Oct 2009

O último ano viu o surgimento de uma quantidade enorme de sites inspirados no Twitter. Alguns tentam traduzir e/ou adaptar para culturas locais, outros tentam expandir o conceito (incluindo fotos, voz, etc.) – isso sem falar em sites já estabelecidos que abraçaram a idéia. Uns foram comprados por gente grande – e vários fecharam, mesmo com alguém bancando.

Era de se esperar que o Yahoo! entrasse nessa arena de alguma forma, mas o Yahoo! Meme superou as minhas expectativas, trabalhando muito bem três aspectos desse tipo de site: o encaminhamento de posts alheios (o “retweet” ou RT do Twitter); a multimídia (turbinada por uma interface que facilita o compartilhamento de fotos, vídeos e músicas sem as ginásticas que o passarinho exige) e a extensibilidade, que permite que terceiros conectem seus sites e aplicativos na plataforma.

A idéia é ótima (ainda mais como alternativa ao famigerado email com PowerPoint anexado e copiado para meio mundo), mas eu e a Bani nos incomodávamos com um lance: a burocracia. Você tinha que copiar o endereço do conteúdo, abrir o Meme, se autenticar, selecionar a mídia, colar o conteúdo e escrever algo sobre ele (do zero). Na nossa cabeça, a coisa só ia rolar se tivesse um botão no navegador que “olhasse” para o conteúdo e cuidasse desse processo todo.

Esse incômodo se juntou com a coceira de brincar com o ecossistema de tecnologias de compartilhamento de dados que o Yahoo! disponbiliza (tais como YQL e oAuth) e fez a gente criar o MemeThis: um site que em poucos segundos gera o tão sonhado botão (bookmarklet, tecnicamente falando) personalizado para a sua conta no Meme.

O código-fonte é escrito em Java, e é livre. A parte dos bastidores (que faz toda a mágica acontecer) roda no Google App Engine – como bem observou um amigo nosso, usamos uma linguagem da Sun para ampliar um serviço do Yahoo! usando um outro serviço do Google. Web 2.0 é isso! :-P

Apesar de ainda ser uma versão beta, já tem bastante gente usando. E agora não é preciso mais mendigar convites: o Yahoo! Meme está aberto para todos, é só ir !

Tweet xkcd bookmarklet

20 Apr 2009

Since people love to post their favorite xkcd strips on Twitter, I thought this might help: drag the link below onto your links toolbar (it will create a button). Whenever you read an xkcd comic you want to share, just...

iPhone Development Rants

10 Oct 2008

(previously published on the MIH SWAT Blog) When we talk about Apple, mankind is pretty much divided into three camps: lovers, haters and developers. Seriously, I never thought the day would come when I’d say such a thing, but the...

Programando para iPhone no Eee PC com Ubuntu

10 Aug 2008

A combinação Eee PC + Ubuntu continua me surpreendendo positivamente: consegui compilar o iphone-dev toolchain, isto é, o kit de desenvolvimento da comunidade para o iPhone (não confundir com o da Apple, que é bacanudo, mas só roda em Macs...

EDGE Switch

08 Aug 2008

O EDGE Switch é um programa que desenvolvi para o iPhone com o objetivo de bloquear/liberar a conexão de dados da operadora (EDGE). Isso é necessário porque o sistema operacional da Apple assume que o seu plano de dados é...

Desenvolvimento para iPhone: instalando o toolchain

11 May 2008

A capacidade de hardware e software já fazem do iPhone uma plataforma atrativa para criar aplicativos. É difícil falar em número de usuários no Brasil - oficialmente são zero, tem relatório dizendo que são um mol. Mas o fato é...

“No, thanks, I can use Meebo for that”

13 Jan 2008

A friend of mine called me this Sunday, happy as a child in a candy shop: she had just got herself a shinny new MacBook, after years lusting over my old-but-cute iBook G4. Of course she wanted tips on how...

miniTruco Client-Server API

12 Jan 2008

miniTruco is an implementation of the Brazilian Truco card game (also known as Truco Paulista or Truco Mineiro) for Java-enabled cellphones. One of its features is its multiplayer ability over the Internet. That is done by having a server software...

Android: Comentários e Desabafos

20 Nov 2007

O Android é uma proposta anunciada recentemente pelo Google para uma arquitetura aberta de telefones celulares que privilegia o usuário e os desenvolvedores independentes de aplicativos - em contraste com as plataformas usadas nos aparelhos atuais (além das soluções para...

Migrando o Movable Type de BerkleyDB para MySQL

20 Sep 2007

As novas versões do Movable Type (publicador deste blog) não vão mais suportar o formato BerkleyDB para guardar os posts, comentários e configurações. Como pretendo atualizar em breve, resolvi adiantar o expediente e migrar para MySQL. Nada muito esotérico: o...

Getting Real

27 Jun 2007

Getting Real abre com uma proposta atraente: ajudar a construir aplicações web de sucesso. Não se trata de uma metodologia - até porque ele se dispõe a questionar muito do material e da cultura que compõem as metodologias (formais ou...

timefix (ou: Acertando o Horário de Verão em Java II)

24 Feb 2007

Ano passado escrevi um texto sobre o problema do Java com o horário de verão, explicando as causas, apontando soluções comuns e sugerindo uma nova - cuja principal vantagem é dispensar alterações no código-fonte da aplicação afetada. Sua maior...

Linguagens de Programação Comparadas

05 Feb 2007

A comparação entre linguagens de programação (e incluem-se aí os ambientes sob os quais estas linguagens operam) é um assunto quase que inesgotável. Quando abordado de forma leviana, acaba em discussões que pouco diferem das mesas-redondas futebolísticas: programadores movidos por...

miniTruco, agora com Bluetooth

28 Jan 2007

Aleluia, a versão Bluetooth do miniTruco finalmente está pronta, permitindo que até 4 pessoas joguem entre si (para quem não conhece, trata-se de um jogo gratuito e de código aberto para celulares que suportam Java). Não tive muita chance de...

Acertando o Horário de Verão em Java

16 Oct 2006

ATUALIZAÇÃO: O método sugerido aqui não lê a configuração de timezone do servidor (e, portanto, exige atualização a cada ano) . Se o seu servidor é Linux ou assemelhado, sugiro usar o timefix. Se você desenvolve aplicações Java para rodar...

A Busca de Epaminondas Jr.

20 Jun 2006

Este jogo, criado no início dos anos 90, foi uma das primeiras coisas que disponibilizei na web, não sem um certo constrangimento: minha definição de "humor" mudou um pouco ao longo dos últimos quinze anos. Embora o jogo não use...

Código-fonte do windows

16 Feb 2004

Código-FontePor esses dias, parte do código-fonte do Windows NT/2000 vazou para a Internet.O que mais se discute é se isso pode viabilizar ataques baseados em vulnerabilidades até então desconhecidas no sistema. Já acharam uma no Internet Explorer 5 (que vem com o Windows 2000), mas esse browser é cheio delas: até eu, um mero mortal, descobri como derrubar o IE5 usando apenas HTML.

Tem bastante coisa na rede cobrindo o assunto, mas eu começaria pelo excelente artigo do Kuro5hin, que foca mais nos comentários deixados pelos programadores ao longo do código do que no próprio. Parece que o pessoal de Redmond andou enrolando e fumando o Code Complete: é um comentário mais engraçado que o outro.

Como a “esquerda Slashdot” da informática tende a só enxergar os deméritos no outro lado da cerca, acho relevante destacar os seguintes pontos (não costumo fazer isso porque a reação natural é atacar a fonte, mas o Kuro5hin é respeitado tanto pelos desenvolvedores sérios quanto pelos wannabees):

*“Despite the above, the quality of the code is generally excellent. Modules are small, and procedures generally fit on a single screen. The commenting is very detailed about intentions, but doesn’t fall into ‘add one to i’ redundancy. “

“The security risks from this code appear to be low. Microsoft do appear to be checking for buffer overruns in the obvious places. The amount of networking code here is small enough for Microsoft to easily check for any vulnerabilities that might be revealed: it’s the big applications that pose more of a risk. This code is also nearly four years old: any obvious problems should be patched by now.”*

Aliás, eu tenho brincado esses dias, dizendo que, de um jeito ou de outro, caiu por terra a única vantagem que o Linux tinha sobre os Windows da família NT, que era a revisão feita por milhares de olhos no mundo todo… :-)

Inclusão digital e a origem do linux

25 Dec 2003

<img src=”img/blig/softlivre.jpg”align=”right” border=”2” alt=”Software Livre e Inclusão Digital”>Uma das grandes virtudes da comunidade do software livre é seu primor pela excelência técnica. Infelizmente, este é o catalisador do que é possívelmente seu maior vício: a disposição que este pessoal tem para dizer bobagens sobre assuntos que pouco entendem – desde o software do concorrente até ética e geopolítica.

J2EE, .Net, o ovo e a galinha

08 Jul 2003

Um dos motivos que me deixam um pouco reticente para escrever sobre informática é que este é um assunto sério, que normalmente é tratado de forma leviana. É fácil perceber neste site que eu prefiro escrever sobre assuntos levianos e tratá-los de forma séria.

E ainda por cima eu encontro bons artigos como este, que mostra uma perspectiva interessante sobre a questão J2EE x .Net. O artigo me causa duas frustrações: não apenas o cara “teve a minha idéia”, como fez isso há seis meses atrás. Mais um ponto para pensar menos e fazer mais.

Macho que é macho programa em Atari

22 Nov 2002

Certa vez escrevi um artigo sobre desenvolvimento de jogos para o videogame Atari 2600. Vira e mexe alguém quer mais informações sobre desenvolvimento pra Atari, e eu costumo recomendar o Stella – uma espécie de “manual oficial do desenvolvedor” – além de alguma coisa sobre Assembly 6502 (que você acha fácil no Google ou em sebos).

Da última vez que eu fui procurar, me deparei com um site que traz o código-fonte comentado (através de um paciente trabalho de engenharia reversa) de jogos como Combat, Freeway e Adventure. Passei uma hora divertidíssima (ok, diversão de nerd) lendo este último de cabo a rabo. Conclusão óbvia, mas indiscutível: esse Warren Robinett (autor do jogo) é um gênio. De marca maior.

Moore x Gates

14 Jun 2002

Todo mundo que tem uma vaga idéia do que é desenvolvimento de software parece ter uma opinião sobre .Net. E quase todos são arrogantes a ponto de acharem possível prever o que vai acontecer com a plataforma (e poucos vão além das posições radicais: ou Bill Gates domina a galáxia, ou tudo termina com o campus da Microsoft em chamas).

Neste contexto sem-graça é muito gratificante ler artigos como .NET Signals an Industry Shift de David Bau (criador da Dave´s Quick Search Bar, um dos programnhas que eu mais sinto falta quando estou usando Linux). O autor traça um panorama interessante de como a lei de Moore traduziu-se no barateamento do hardware e como isso foi afetando a indústria e a estratégia da Microsoft.

Dave não se arrisca a responder as dúvidas sobre o futuro (ele encerra o texto com a corente questão “quando a poeira baixar, quem vai estar de pé?”), e justamente por este pé-no-chão que eu recomendo a leitura.

Por trás dos emuladores

21 May 2002

</div> <div class=mensagem>Para quem nunca viu: emuladores são programas que simulam o funcionamento de computadores ou videogames antigos, permitindo que se rode os programas destas máquinas nos micros modernos (veja e pegue aqui alguns deles).</p> Estes programas, nem sempre legais, são desenvolvidos geralmente por programadores solitários – no máximo, pequenos grupos colaborando através da Internet. E eu me diverti muito visitando o Emu-Celebs, um site dedicado a mostrar as pessoas por trás deste universo: programadores, webmasters, organizadores de ROMs (cópias dos softwares). Pra quem já reviveu um Atari ou MSX virtual vale a pena perder uns minutos aqui.</div> <div class=mensagem>

Repensando o desenvolvimento de software com Joel Spolsky

18 Mar 2002

Eu sempre fui contra a idolatria de pessoas, vivas ou mortas, até que conheci o trabalho de Joel Spolsky. Ele já foi desenvolvedor da Microsoft, da Juno e outros lugares interessantes. Hoje Joel tem sua própria empresa, e se tornou o meu guru espiritual quando o assunto é desenvolvimento de software. Não estou falando da parte técnica do assunto (isso já tem ótimos autores), mas sim da parte gerencial, que na maioria das empresas é dilbertiana demais para uma suposta ciência exata…

Em seu site acontecem discussões de altíssimo nível que tentam desmistificar esta mistura bizarra de engenharia e arte, e hoje encontrei um artigo ótimo, meio antigo até, no qual Spolsky defende que o verdadeiro foco de uma empresa de software deve ser “converter talento em código”, e não perder tempo e dinheiro com atividades secundárias. O artigo é indispensável para quem tem qualquer influência gerencial neste processo.

Os técnicos não podem passar sem ler User Interface Design for Programmers, um convite a se repensar a maneira com que as interfaces com o usuário são criadas. Enfim, o site inteiro é ótimo, Joel é meu pastor, nada me faltará!

Truco para Windows/Linux

07 Mar 2002

Há alguns anos eu comecei a desenvolver um jogo de Truco para Windows. O projeto caminhou bastante, mas nunca tive tempo de acabar.

Como falta pouca coisa, resolvi disponbilizar o código-fonte para que algum programador Delphi ou Kylix que se interesse complete o jogo. Alguém se habilita?