Source Code

The source code of micro-tweet is exactly 137 characters, which is short enough to fit in a single tweet :

import sys,twitter as t;p=sys.argv;a=t.Api(*p[1:3]);m=a.GetFriendsTimeline()[0];print m.user.name+':',m.text;p[3:] and a.PostUpdate(p[3])

Installation

1. Install Python.
2. Install the simplejson library.
3. Install the python-twitter library.
4. Copy the client source code (above) and paste it into a new file. Save it as “micro-tweet.py”.

Usage

To run the client, execute micro-tweet.py using the Python interpreter and pass your Twitter username and password as the script arguments. This will output the latest tweet from your friends time line:

python micro-tweet.py username password

To post a status update, pass the tweet text as the third script argument. The following example will again output the latest tweet from your friends time line and post “Your tweet here!” (sans quotes) to Twitter:

python micro-tweet.py username password "Your tweet here!"

Note that the tweet text needs to be enclosed in quotes for it to be posted properly. Use "double quotes" on Windows and 'single quotes' on *nix-like systems. You will not receive any confirmation as to whether your tweet was posted successfully or not. To check, visit twitter.com or fire up a different Twitter client.

Why micro-tweet?

Just for fun

micro-tweet was a little project I did over the weekend. The goal was to see if I could squeeze the essential features of a “real” Twitter client – reading and posting tweets – into less than 140 characters. It also served as a nice work-out for my rusty Python skills.

And yes, I’m aware that using a pre-existing library to interface with the Twitter API might be considered “cheating”, but it would be downright impossible to fit the script into the size constraints without it. The API endpoint URLs alone would probably be long enough to push the script over the limit.

I also like to keep my browser window trim and slim, and a crowded bookmark bar is definitely not conducive to that. Therefore, I have created a web app that lets you combine multiple bookmarklets into one. The combined bookmarklet can be configured either to display a pop-up menu of the input bookmarklets, or to automatically run them all.

Behold, the Bookmarklet Combiner:

And below is the combined bookmarklet that I was working on when I took this screenshot. Note that it may not work properly in IE.

Dev Tools

Usage Instructions

Here’s how to create your own combined bookmarklet :

1. Enter the bookmarklets that you want to combine.
   1. Open the homepage of the bookmarklet that you want to add to the combination.
   2. Right-click on the bookmarklet and select “Copy link address” (or the equivalent) from the pop-up menu.
   3. Paste the copied URL in the combiner’s “URL” box.
   4. Enter the bookmarklet name in the corresponding “Title” box.
   5. Repeat steps 1. – 4. for all other bookmarklets.
2. Select the combination type.
3. Enter the name to use for the combined bookmarklet.
4. Drag the combined bookmarklet from the “Result”  box to your bookmark bar.

The bookmarklet in the “Result” box is updated automatically whenever you modify the inputs. You don’t need to click or press anything to start the combination process.

Tip : You can also enter a standard HTTP URL in the “URL” box. If the combined bookmarklet is set to display a menu, the corresponding menu entry will be a simple link. If it’s set to “Run all”, the combined bookmarklet will attempt to open each URL in a new window/tab. However, this only works in browsers that don’t block pop-ups created by bookmarklets.

Disclaimer : The Bookmarklet Combiner does not work properly in Internet Explorer. Also, permanently saving bookmarklets on the server is not yet possible.

About

Basically, with this plugin you can insert a little piece of code into your theme and get nice fuzzy timestamps for your posts/pages (see the Usage section below for details). The timestamps will even update automatically – that is, if you open a page that has a timestamp saying “Posted 1 minute ago” and wait 10 minutes without reloading the page, the timestamp will then say “Posted 11 minutes ago”. People who have JavaScript disabled will see normal, non-fuzzy timestamps instead.

Here’s a screenshot showing several example timestamps :

Note : The calendar icon is not included with the plugin. The site in the screenshot is using the iNove theme which adds these cute icons to post timestamps.

Download

fuzzy-timestamp.zip (4 KB)

Requirements :

• WordPress 2.9+
• PHP 5

Usage

Once you’ve installed and activated the plugin, go to the theme editor and insert <?php do_action('fuzzy_timestamp'); ?> whereever you want to use a fuzzy timestamp. For example, to use fuzzy timestamps on single post pages, open the single.php template file and replace any the WordPress loop; i.e. you can’t use to change the comment timestamps (yet).

You can also pass a second parameter to the do_action() function to specify the datetime format for the tool-tip that shows up when you mouse over a fuzzy timestamp (people who have JavaScript disabled will also see the timestamp in this format). The parameter syntax is equivalent to that used by the the_time() template function.

For example, if your theme displays the timestamps using code like this :

<?php the_time('F jS, Y'); ?>

You can add the ”F jS, Y’ bit to the plugin’s code to use the same datetime format for the tool-tips and the no-JS fallback :

<?php do_action('fuzzy_timestamp', 'F jS, Y'); ?>

The timeago script also supports i18n/different languages, but I left that feature out to avoid over-complicating the plugin. Let me know if you’d like to see it added.

But enough about my habits – lets talk convenience. Manually checking your AdSense earnings is not very convenient – you need to navigate to their site, log in, pick the time period you want to examine from the drop-down… The process is simple, but if you religiously check your stats several times per day (like I do) it can get tedious. Wouldn’t it be nice if there was some kind of a widget that would let you see all of your vital AdSense stats at a glance?

Turns out there are several, but most of them don’t work (any more) and are not supported by their authors. So I took the widget that looked the most promising – AdSensor – and fixed it. You can download the widget below.

What Is AdSensor?

AdSensor is a widget that regularly queries your Google AdSense account and displays up-to-date information about earnings and clicks in the form of a compact table. Update frequency is configurable. The widget also comes with four beautiful skins, works both on Windows and Mac, and is available two different languages : English and Finnish. The widget requires the Yahoo! Widgets framework.

You can find more information about this widget on the author’s site.

Download

Download AdSensor 2.9 – the patched version
File size : 196 KB. Requires the Yahoo! Widgets framework.

If you’re having problems with the above link, try the zipped version.

Patch Notes

My version is functionally almost completely identical to the original AdSensor widget. Most of the changes were internal :

• The original login routine relied on cookie-parsing magic and a hard-coded list of form field values. I added a simple regex-based parser that dynamically extracts the actual fields from the login form. This way, there’s a good chance the widget will continue working if Google decides to add a new hidden field to the form.
• I also rewrote the regex that extracts the data on earnings and clicks from Google AdSense reports. For reasons unknown, the original regex would cause the widget to hang permanently on my system.
• Finally, I made the earnings column display the right currency symbol (it can be either dollars or euros, depending on your country of residence and account settings).

I’ve written a Greasemonkey script that hides the “Latest results for “keyword”" box. It also suspends the live updates, preventing Google from wasting your bandwidth needlessly. Just install this userscript, and you won’t see the real-time results again.

Install “Disable Google Realtime Search” (2 KB)

Compatible browsers :

• Firefox + the Greasemonkey extension.
• Opera (see userscripts in Opera).
• Google Chrome 4.0

Sidenote : Even with this script installed, you can still access the realtime results directly by clicking on the “Latest updates” link in search options.

Installation

This userscript is compatible both with Greasemonkey/Firefox and Opera.

For Firefox :

1. Get Greasemonkey.
2. Install Deframe.
3. Add the sites you want to use it with to the “Included Pages” list in Greasemonkey. To access this list, right-click the GM icon, click Manage User Scripts… and select Deframe from the script listing.

For Opera :

1. Go to Tools > Preferences > Advanced > Content > JavaScript options, and select the directory where you will put your User JavaScript files. I recommend creating a new directory for this purpose.
2. Download deframe.user.js and place it in that directory.
3. Open deframe.user.js in a text editor, e.g. Notepad.
4. Add a new include rule for each site that you want to use the script with. Here are a few examples :

   // @include        http://www.stumbleupon.com/su/*
   // @include        http://ow.ly/*
   // @include        http://www.linkive.com/home/browser/*

5. Save and close the file. Opera will automatically load and execute it the next time you navigate to a new page.

How It Works

Most other frame-busting and toolbar-killing scripts rely on site-specific algorithms. They’re easy to write, but inflexible and easily broken by small changes in the site’s design or layout. The only way to adapt them to other sites/toolbars is to manually edit the source code.

Deframe is different – instead of a hard-coded list or per-site algorithms, it uses a very simple yet effective heuristic to identify the frame that’s most likely to contain the actual content of the page.  Here’s the algorithm in a nutshell : find the biggest visible frame that contains a page from a different domain. Then redirect the browser to the frame’s source URL.

Despite the apparent simplicity, this heuristic actually works very well. It correctly detected the content frame on all the social bookmarking links and assorted other sites that I threw at it. If you do find a site that it doesn’t work with, feel free to let me know by leaving a comment below.

The way it works is simple : when you see a web page you’d like to keep track of (e.g. an interesting forum discussion), click a button to save the current version of that page. Then, when you revisit that page at a later time, simply click another button to instantly highlight all the new text and images that have been added since your previous visit. You can also configure the script to do one or both of those steps automatically for all pages of a specific site.

Screenshots

Highlighting a new comment

Highlighting new images

The highlighting algorithm doesn't work that great on complex or frequently updated sites, yet.

Newslight's Greasemonkey menu

Download

Install Newslight.user.js (15 KB, requires FF 3.5+)

Once installed, you can access the script’ s features by right-clicking the Greasemonkey icon on your status bar and selecting “User Script Commands…” from the pop-up menu :

• Remember this version of the page – stores the current version of the page for later reference.
• Highlight changes – compares the contents of the current page to the latest saved version and highlights any new text/images. Clicking this again will toggle the highlighting on/off.
• Automatically remember pages on example.com (on/off) – automatically remember the contents of every page that you visit on this site.
• Automatically highlight changes on example.com (on/off) – automatically highlight new items on all pages of this site.

You can also use these two bookmarklets to quickly access the script’s main functions without going through the Greasemonkey menu. Just drag them to your bookmark bar :

• Remember this page
• Highlight changes

How It Works

I’ll be the first to admit that the highlighting algorithm is very primitive. For example, changing a single word in a paragraph will make the script highlight the entire paragraph, whereas swapping two paragraphs of an article will go completely undetected and un-highlighted. The reason it happens is the way the userscript works : instead of using complex tree manipulation or advanced stuff like revision tracking, it grabs all the text and image nodes from the web page and dumps them into a big lookup table (removing duplicates in the process). Then, when you ask it to highlight changes, it just loads up the aforementioned table and checks the current version of the page against it. Anything that’s not in the table gets highlighted. The actual algorithm for finding new items takes only a couple dozen lines.

For those interested in the technical details, here’s a quick run-down :

• The lookup table is just a simple wrapper around a plain JS object being used as an associative array.
• The table is encoded in JSON and stored in a localStorage database (available in FF 3.5 and up). I’m using the PersistJS library to handle the particulars, which should make it easier to port the userscript to other browsers eventually.
• I tried various ways of fetching all text nodes from a DOM tree, but using the “//text()” XPath expression turned out to be the fastest and most straightforward approach, at least in this case.
• Miscellaneous stuff, like adding/removing the CSS classes and showing pop-up notifications, is done either via direct DOM manipulation or jQuery.

There’s certainly a lot of room for improvement – e.g. configurable highlight colours, converting the script to a proper FF addon,  better UI etc. – but the inherent simplicity of the algorithm is quite intentional. It’s not meant to precisely pinpoint new items on a site, but rather to serve as a useful hint as to where you might find them; an imperfect but handy filter.

Why do it this way? Because determining what counts as new is ultimately an AI-hard problem – you’d need software with near-human intelligence to solve it. Sure, you could probably get a decent approximation by devoting a few weeks to research, but I’d rather have something up and running now, so I can collect some feedback and see if it’s worth doing that research

Big Words, or The Theoretical Part

Fluid dynamics is a complex topic. If you so much as look it up in Wikipedia, you will be immediately assaulted by integrals, differentials and other agents of mathematical insanity. To accurately model a fluid you would need a quite an in-depth understanding of physics and calculus. And while that’s certainly not something one couldn’t figure out given enough time, “proper” fluid simulation is still extremely rare in non-academic applications and games because it’s slow.

One way to create a faster (though less accurate) simulation is by using cellular automata to represent the water. A cellular automaton is basically a grid where each cell can be in one of a finite number of states, plus a set of rules that determine how a cell can change from one state to another. The rules are typically local – that is, they consider only the current cell and it’s direct neighbours when determining the new state. During each step of the simulation, you simply loop through the entire grid and apply the rules to each cell.

When simulating water or other fluids it can more appropriate to store a continuous value (e.g. water mass) in each cell, instead of using discrete states.

CA-Based Water Simulation

Before we go into details, lets take a look at the promised online demo. It will give you a good idea about what you can achieve with this approach :

(klicken Sie auf das Bild; Java required)

Alright, on to the code stuff. Lets try simulating the most common fluid – water.

The basic data structure

//Map dimensions
final int map_width = 16;
final int map_height = 16;
 
//Block types
final int AIR = 0;
final int GROUND = 1;
final int WATER = 2;
 
//Data structures
int[][] blocks = new int[map_width+2][map_height+2];
 
float[][] mass = new float[map_width+2][map_height+2],
          new_mass = new float[map_width+2][map_height+2];

I use two two-dimensional arrays to represent the simulation world. The blocks array defines a basic “map” where each cell can contain ground (solid, stops water flow), air (an empty cell, water can flow in) or water. Each water cell also has a corresponding entry in the mass array that defines how much water it contains. All water cells/blocks start out with one unit of water.

There’s also a third array – new_mass that is used to store intermediate mass values when running the simulation. Operating directly on the mass array is unadvisable because you would get various sideffects like water spreading at different speeds depending on the order in which you update the cells.

Overall algorithm

The main idea is to treat water as a slightly compressible liquid, as described in this article. In terms of implementation, this means that if there are two or more water cells stacked vertically, the bottom cells will be able to hold slightly more water than normal. This way we don’t need to explicitly track pressure to make the water level equalize in communicating vessels – we can just look at how much excess water a cell has, and move it upwards if required.

Lets set up the exact fluid properties as constants :

//Water properties
final float MaxMass = 1.0; //The normal, un-pressurized mass of a full water cell
final float MaxCompress = 0.02; //How much excess water a cell can store, compared to the cell above it
final float MinMass = 0.0001;  //Ignore cells that are almost dry

For example, if one cell contains 1.0 units of water, the cell below it should contain up to 1.02 units, the cell below that one should contain 1.04, the next one 1.06, and so on. There is one however special case that we need to consider to get a plausible simulation – what if the if the top cell contains less than MaxMass units of water? In my implementation the bottom cell will contain a proportionally smaller excess amount, not the usual mass_of_the_cell_above + MaxCompression units.

Based on the above, we can simulate water movement by looping over the mass array and applying these cellular automaton rules to each cell :

1. Take the mass of the current cell and the cell below it and figure out how much water the bottom cell should contain. If it has less than that, remove the corresponding amount from the current cell and add it to the bottom cell.
2. Check the cell to the left of this one. If it has less water, move over enough water to make both cells contain the same amount.
3. Do the same thing for the right neighbour.
4. Do the same thing as in step 1., but for the cell above the current one.

While doing this you also need to keep track of how much water the current cell still has remaining, or you could end up with negative-mass water blocks.

After the new mass of each cell has been calculated, you can safely copy over the new values to the mass array. You also need to update the blocks array so that cells that are now dry get marked as empty and vice versa.

Here’s the simulation code :

void simulate_compression(){
  float Flow = 0;
  float remaining_mass;
 
  //Calculate and apply flow for each block
  for (int x = 1; x <= map_width; x++){
     for(int y = 1; y <= map_height; y++){
       //Skip inert ground blocks
       if ( blocks[x][y] == GROUND) continue;
 
       //Custom push-only flow
       Flow = 0;
       remaining_mass = mass[x][y];
       if ( remaining_mass <= 0 ) continue;
 
       //The block below this one
       if ( (blocks[x][y-1] != GROUND) ){
         Flow = get_stable_state_b( remaining_mass + mass[x][y-1] ) - mass[x][y-1];
         if ( Flow > MinFlow ){
           Flow *= 0.5; //leads to smoother flow
         }
         Flow = constrain( Flow, 0, min(MaxSpeed, remaining_mass) );
 
         new_mass[x][y] -= Flow;
         new_mass[x][y-1] += Flow;   
         remaining_mass -= Flow;
       }
 
       if ( remaining_mass <= 0 ) continue;
 
       //Left
       if ( blocks[x-1][y] != GROUND ){
         //Equalize the amount of water in this block and it's neighbour
         Flow = (mass[x][y] - mass[x-1][y])/4;
         if ( Flow > MinFlow ){ Flow *= 0.5; }
         Flow = constrain(Flow, 0, remaining_mass);
 
         new_mass[x][y] -= Flow;
         new_mass[x-1][y] += Flow;
         remaining_mass -= Flow;
       }
 
       if ( remaining_mass <= 0 ) continue;
 
       //Right
       if ( blocks[x+1][y] != GROUND ){
         //Equalize the amount of water in this block and it's neighbour
         Flow = (mass[x][y] - mass[x+1][y])/4;
         if ( Flow > MinFlow ){ Flow *= 0.5; }
         Flow = constrain(Flow, 0, remaining_mass);
 
         new_mass[x][y] -= Flow;
         new_mass[x+1][y] += Flow;
         remaining_mass -= Flow;
       }
 
       if ( remaining_mass <= 0 ) continue;
 
       //Up. Only compressed water flows upwards.
       if ( blocks[x][y+1] != GROUND ){
         Flow = remaining_mass - get_stable_state_b( remaining_mass + mass[x][y+1] );
         if ( Flow > MinFlow ){ Flow *= 0.5; }
         Flow = constrain( Flow, 0, min(MaxSpeed, remaining_mass) );
 
         new_mass[x][y] -= Flow;
         new_mass[x][y+1] += Flow;   
         remaining_mass -= Flow;
       }
 
 
     }
  }
 
  //Copy the new mass values to the mass array
  for (int x = 0; x < map_width + 2; x++){
    for (int y = 0; y < map_height + 2; y++){
      mass[x][y] = new_mass[x][y];
    }
  }
 
  for (int x = 1; x <= map_width; x++){
     for(int y = 1; y <= map_height; y++){
       //Skip ground blocks
       if(blocks[x][y] == GROUND) continue;
       //Flag/unflag water blocks
       if (mass[x][y] > MinMass){
         blocks[x][y] = WATER;
       } else {
         blocks[x][y] = AIR;
       }
     }
  }
 
  //Remove any water that has left the map
  for (int x =0; x < map_width+2; x++){
    mass[x][0] = 0;
    mass[x][map_height+1] = 0;
  }
  for (int y = 1; y < map_height+1; y++){
    mass[0][y] = 0;
    mass[map_width+1][y] = 0;
  }
 
}

And here’s the function that calculates how to distribute a given amount of water between two vertically adjacent cells :

//Returns the amount of water that should be in the bottom cell.
float get_stable_state_b ( float total_mass ){
  if ( total_mass <= 1 ){
    return 1;
  } else if ( total_mass < 2*MaxMass + MaxCompress ){
    return (MaxMass*MaxMass + total_mass*MaxCompress)/(MaxMass + MaxCompress);
  } else {
    return (total_mass + MaxCompress)/2;
  }
}

Full source code

• Download the source (23 KB)
• You will need the Java-based Processing programming language to run the code.

I didn’t discuss how to render the water, or how to handle user interaction, but the source code also includes a simplistic implementation of those things.

Conclusion

CA-based algorithms have both advantages and disadvantages. On the one hand, they’re relatively fast and the simulation quality is often good enough for games and software toys. On the other, they can produce behaviour that is very unrealistic – for example, water falling into a basin will form a little “hill” and spread out slowly, instead of near-instantly as real water would. Whether this is an acceptable downside depends on your application.

For a different take on simulating fluid dynamics with cellular automata, check out this interview with the author of Dwarf Fortress.

This gave me the idea to write a PHP script that can generate a wordpress.org-compatible changelog from the revision log. It works for any plugin hosted in the official plugins directory and can be a handy starting point for adding a changelog to plugins that don’t have it yet :

• Run the changelog generator
• Download the source code (97 KB, requires PHP 5)

For those too lazy to click one of the above links, here’s a screenshot :

And I really do need to stop making these small hacks

But if we’re wasting time we should at least waste it efficiently, right? One of the inefficiencies of this game is that the serverlist is not sortable – if you want to find a populated server you have to look over the entire listing that typically contains 50-100 active server at any given moment.

That’s why I made a GreaseMonkey script that lets you sort the Minecraft serverlist as you like. It adds two new links to the serverlist – “Sort by players” and “Sort by name”. The default is to sort by the number of active players which will put the most populated servers at the top of the page (this can be easily changed by editing one line in the script).

Download userscript!

P.S.
I’m aware that blog updates have been lacking lately. I hope to remedy with this unfortunate situation in the nearest future.