WebGL Orrery

I wrote a small WebGL orrery a month back or so, using planet and orbit data from Wikipedia. The orbits came out a bit wrong (planet positions on orbits are wrong, the planet rotation axis rotates along the orbit, planets velocities are constant, the orbits / axes may well be flipped somewhere), but it's a passably "realistic" orrery. Well, realistic apart from the whole having to scale down orbits by a factor of thousand to make the planets visible -thing. With 1:1 orbits, the planets are smaller than a pixel in size when viewed from other planets and the sun is about a pixel in diameter when viewed from Neptune.

It's quite extensible too, it should be possible to add in all the moons just by filling in their data. The coordinate system and z-buffer aren't accurate enough to do anything fancy like a spaceship sim with 1:1 orbits though :)

A deck of cards

If not for the order property, you could cram a deck of cards into a 64-bit int. Though if you had a RNG cyclical in full_deck_size, that'd work to preserve the order property. Which would be enough for poker and other stackless or write-only stack card games.

With the cyclical RNG you could pop a card off a full deck in O(1). With incomplete decks (that is, a deck with non-RNG-generated cards removed) you'd need to go through random cards until the generated card is in the deck. The worst-case time-complexity for popping all cards off an incomplete deck would be O(full_deck_size) and the average complexity for popping one card off an incomplete deck would be O(full_deck_size/incomplete_deck_size). Anyhow, incomplete decks would be as fast or slow as full decks, with an extra existence check slowing them down a bit further. The RNG would need a seed with log₂(fac(full_deck_size)) bits, so log₂(52!) = 226 bits for a deck without jokers.

A naive version of the RNG would be to generate a random number between 0 and 52!-1, then convert the number into 52 digits in factorial base. Divide first by 51!, the result is the first card. Divide the remainder by 50!, the result is the second card (note that you have to remove the first card from consideration for the second card index). Continue dividing the remainders until you have 52 cards. Or just generate a shuffled 52 element array of numbers and go through that :P

... I should get back to work now.

Source

#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

typedef int64_t card_mask;
typedef int8_t card;

typedef struct deck {
  card cards[55];
  int8_t length;
  card_mask mask;
} deck_t;

#define suit_size 13

static const card_mask hearts = suit_size*0;
static const card_mask spades = suit_size*1;
static const card_mask clubs = suit_size*2;
static const card_mask diamonds = suit_size*3;
static const card_mask jokers = suit_size*4;

static const char* suits[5] = {"Hearts", "Spades", "Clubs", "Diamonds", "Jokers"};
static const char* ranks[13] = {
  "Ace", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
  "Jack", "Queen", "King"
};

card_mask remove_cards_from_mask(card_mask deck, card_mask cards)
{
  return deck & ~cards;
}

card_mask add_cards_to_mask(card_mask deck, card_mask cards)
{
  return deck | cards;
}

card_mask query_mask(card_mask deck, card_mask cards)
{
  return deck & cards;
}

card_mask mask_of_card(card c)
{
  return (card_mask)1 << (card_mask)c;
}

card card_for_suit_and_rank(card_mask suit, card_mask rank)
{
  return suit + rank;
}

int deck_initialize(deck_t *deck, int jokers)
{
  card c = 0;
  if (jokers < 0 || jokers > 3) 
    return 0;
  deck->length = 52 + jokers;
  deck->mask = ((card_mask)1 << (card_mask)deck->length)-1;
  for (c=0; c<deck->length; c++) {
    deck->cards[c] = c;
  }
  return 1;
}

void deck_clear(deck_t *deck)
{
  deck->length = 0;
  deck->mask = 0;
}

void deck_shuffle(deck_t *deck)
{
  int8_t i,j;
  card tmp;
  for (i=deck->length-1; i>0; i--) {
    j = rand() % (i+1);
    tmp = deck->cards[j];
    deck->cards[j] = deck->cards[i];
    deck->cards[i] = tmp;
  }
}

card_mask deck_query_mask(deck_t *deck, card_mask m)
{
  return query_mask(deck->mask, m);
}

card_mask deck_query_card(deck_t *deck, card c)
{
  return deck_query_mask(deck, mask_of_card(c));
}

card_mask deck_query_deck(deck_t *deck, deck_t *deck2)
{
  return deck_query_mask(deck, deck2->mask);
}

int deck_add(deck_t *deck, card c)
{
  card_mask m = mask_of_card(c);
  if (query_mask(deck->mask, m)) {
    return 0;
  } else {
    deck->mask = add_cards_to_mask(deck->mask, m);
    deck->cards[deck->length] = c;
    deck->length++;
    return 1;
  }
}

int deck_remove(deck_t *deck, card c)
{
  int8_t i=0, j=0;
  card_mask m = mask_of_card(c);
  if (!query_mask(deck->mask, m)) {
    return 0;
  } else {
    deck->mask = remove_cards_from_mask(deck->mask, m);
    for (i=0,j=0; i<deck->length; i++) {
      if (deck->cards[i] != c) {
        deck->cards[j] = deck->cards[i];
        j++;
      }
    }
    deck->length = j;
    return 1;
  }
}

card deck_pop(deck_t *deck) 
{
  card c;
  if (deck->length < 1) {
    return -1;
  } else {
    deck->length--;
    c = deck->cards[deck->length];
    deck->mask = remove_cards_from_mask(deck->mask, mask_of_card(c));
    return c;
  }
}

const char* suit_string(card s)
{
  if (s >= suit_size*5) 
    return "Invalid";
  return suits[s / suit_size];
}

const char* rank_string(card s)
{
  return ranks[s % suit_size];
}

void print_card(card c)
{
  printf("%s of %s\n", rank_string(c), suit_string(c));
}

void print_deck(deck_t *deck)
{
  int8_t i;
  printf("Deck %p:\n", (void*)deck);
  for (i=0; i<deck->length; i++) {
    print_card(deck->cards[i]);
  }
}

void print_mask(card_mask m)
{
  int i;
  const char* symbols[5] = {"♥", "♠", "♣", "♦", "☻"};
  for (i=0; i<64; i++) {
    if (i%suit_size == 0) printf(" %s", symbols[i/suit_size]);
    if ((m>>i) & 1) putchar('#');
    else putchar('.');
  }
  putchar('\n');
}

int main() 
{
  int i=0;
  deck_t deck, hand;
  card c;
  srand(time(NULL));
  deck_initialize(&deck,2);
  deck_initialize(&hand,0);
  deck_clear(&hand);
  deck_shuffle(&deck);
  printf("Deck %p has %d cards and mask %ld.\n", (void*)&deck, deck.length, deck.mask);
  print_mask(deck.mask);
  for (c=0; c<54; c++) {
    if (!deck_query_card(&deck, c)) {
      printf("Error: Deck doesn't have a card.\n");
      print_card(c);
    }
  }
  printf("Hand %p has %d cards and mask %ld.\n", (void*)&hand, hand.length, hand.mask);
  print_mask(hand.mask);
  for (c=0; c<54; c++) {
    if (deck_query_card(&hand, c)) {
      printf("Error: Hand has a card it shouldn't have.\n");
      print_card(c);
    }
  }
  deck_remove(&deck, hearts);
  if (deck_query_card(&hand, hearts)) 
    { printf("Error: Hand has a card it shouldn't have.\n"); print_card(hearts); }
  deck_remove(&deck, spades);
  if (deck_query_card(&hand, spades)) 
    { printf("Error: Hand has a card it shouldn't have.\n"); print_card(spades); }
  deck_remove(&deck, clubs);
  if (deck_query_card(&hand, clubs)) 
    { printf("Error: Hand has a card it shouldn't have.\n"); print_card(clubs); }
  deck_remove(&deck, diamonds);
  if (deck_query_card(&hand, diamonds)) 
    { printf("Error: Hand has a card it shouldn't have.\n"); print_card(diamonds); }
  printf("Deck %p has %d cards and mask %ld.\n", (void*)&deck, deck.length, deck.mask);
  print_mask(deck.mask);
  for (i=0; i<5; i++) {
    c = deck_pop(&deck);
    print_card(c);
    deck_add(&hand, c);
  }
  printf("Deck %p has %d cards and mask %ld.\n", (void*)&deck, deck.length, deck.mask);
  print_mask(deck.mask);
  printf("Hand %p has %d cards and mask %ld.\n", (void*)&hand, hand.length, hand.mask);
  print_mask(hand.mask);
  print_deck(&hand);
  if (deck_query_deck(&deck, &hand) || deck_query_deck(&hand, &deck)) {
    printf("Error: Deck and Hand intersect.\n");
  } else {
    printf("Deck and Hand are disjoint.\n");
  }
  for (i=0; i<hand.length; i++) {
    if (deck_query_card(&deck, hand.cards[i])) {
      printf("ERROR ");
    } else {
      printf("OK ");
    }
  }
  printf("\n");
  for (i=0; i<deck.length; i++) {
    if (deck_query_card(&hand, deck.cards[i])) {
      printf("Error: Found a card in Deck that is in Hand.\n");
      print_card(deck.cards[i]);
    }
  }
  print_card(suit_size*5);
  return 0;
}

Output

$ ./a.out 
Deck 0x7fff98907250 has 54 cards and mask 18014398509481983.
 ♥############# ♠############# ♣############# ♦############# ☻##..........
Hand 0x7fff98907210 has 0 cards and mask 0.
 ♥............. ♠............. ♣............. ♦............. ☻............
Deck 0x7fff98907250 has 50 cards and mask 18013848686551038.
 ♥.############ ♠.############ ♣.############ ♦.############ ☻##..........
Eight of Hearts
Seven of Clubs
Ten of Diamonds
Six of Diamonds
Nine of Hearts
Deck 0x7fff98907250 has 45 cards and mask 17714777228828286.
 ♥.######..#### ♠.############ ♣.#####.###### ♦.####.###.### ☻##..........
Hand 0x7fff98907210 has 5 cards and mask 299071457722752.
 ♥.......##.... ♠............. ♣......#...... ♦.....#...#... ☻............
Deck 0x7fff98907210:
Eight of Hearts
Seven of Clubs
Ten of Diamonds
Six of Diamonds
Nine of Hearts
Deck and Hand are disjoint.
OK OK OK OK OK 
Ace of Invalid

Yet more GREAT ideas

Amateur astronomer telescopes, live video streaming, combine the different observations into high-res frames: live 24/7 HD webcams of the planets.

Speckle imaging
Compressed sensing
Image Deblurring with Blurred/Noisy Image Pairs

More GREAT ideas

Take The European Citizens' Initiative, add a public forum, link it up with EU proceedings, build a Citizens' Parliament.

The ECI proposal says that you need a million signatories to send a citizens' initiative to the European Commission. The EC is the main proposal-generating entity in the EU. The European Parliament, in contrast, is the proposal-filtering entity (now with new proposal-generating powers granted to it by the Lisbon Treaty). In that sense, the ECI impacts the very top of the EU legislative system.

The million signatories must include 0.2% of the voting-age citizens for a third of the member states to be valid. And after collecting 300 000 statements of support, you must submit it to the EC for an admissibility acid check where the EC figures out whether they can legally do it or not. After two months, you should get back a yay/nay. And you can collect the statements of support online as long as your mechanism is secure (further details pending).

After that, 3 months of checking the signatures for validity by the member states using random sampling. After that, 4 months of examination by the EC, at the end of which it "would then be required to set out its conclusions on the initiative and the action it intends to take in a communication, which would be notified to the organiser as well as to the European Parliament and Council and would be made public."

Not the most blisteringly fast method of democratic participation, is it? Still, it's very interesting.

I wonder how much governance is a problem of thinking power (in terms of "need more heads to think better solutions!") and how much a sensor network problem ("need to know what's wrong with the world to fix it!") and how much a problem of integrating the two into a working system. How would this kind of a wide-ranging massively large parliament work best?

A large and diverse population has experts from all the different walks of life. Which is probably where the thinking power of the citizens' parliament would best manifest. But you need to find the best proposals from the noise of mediocre proposals. Then you have the sensor network side, where a large population is again an asset. But again, there's a large amount of noise with a large population. So perhaps the important thing is making a good network to filter the signal.

Storage visions

Some sort of user-friendly UI to ZFS+Plan9. One big main filesystem that spans several drives and automatically does striping, mirroring and versioning. Fast drives are used as cache, big drives as mirrors and history.

Plug in a new internal drive and usable space, redundancy and total performance grows by some percentage of the new drive's specs. Bring a new computer in the local area network and the filesystems on the computers are merged into a network-wide filesystem, adding usable space, redundancy and performance.

Pull out a drive and the file system rebalances itself over the remaining drives. If some files require the pulled out drive, display notification and freeze the files until the drive is restored. Use a disk utility to separate a drive from the filesystem into a new filesystem, the utility copies files unique to the drive to other drives and disconnects and formats the separated drive when done.

Computers on the local network are used as page cache and as mirrors of the filesystem. Cloud service is used as a backup mirror and remote sync. Treat the entire memory hierarchy and network as parts of the same single filesystem. When on the network, it doesn't matter which computer or which disk has the file, apart from performance.

Transient devices carry a small local cache of the important things on the filesystem, and access the rest of the filesystem over the network. Either by connecting to the home network or by going through the cloud service. The local cache of the filesystem prioritizes metadata over the actual data and access to the actual data can usually be done by streaming a low-bandwidth version.

*mirrorshades*
*techno soundtrack*
*sunrise*

How many dwarfs live in Mt. Everest

Dwarfs, those earth-dwelling little buggers, grand masters of volume. What if they burrowed the entire Mount Everest into a big dwarf-warren? Let's find out!

First, some assumptions.

Dwarfs are clearly good at cramped living as they live in mostly closed-off subterranean cities. They have also mastered the art of stonecraft to a magical level, so their buildings may well compare favorably to modern ferro-concrete towers. Let's assume that a dwarven city boasts a similar population density as urban Hong Kong, i.e. 250000 dwarfs per square kilometer with an average building height of 45 meters. A cubic kilometer of dwarvopolis would consist of 20 such layers and have a population of 5 million dwarfs.

Mount Everest is kinda pointy, but not all that pointy. Let's suppose that its slope is 45 degrees and that it approximates a cone. That would give it around 720 cubic kilometers in volume. But don't forget that dwarfs are subterranean, so we could reasonably assume that the dwarven city of Sagarmatha extends an extra kilometer under the surface with dwarven suburbia sprawling in a 10 kilometer radius. With the subterranean suburbs added, our dwarven city would have a total volume of around one thousand cubic kilometers.

From which a simple multiplication leads us to a total Sagarmatha dwarvopolitan population of 5 billion.

But why stop at Everest? Cast your net wider! The entire population of the Great Himalayan Dwarven Realm would be... the area of Himalayas is around 610000km^2, Tibetan plateau height is 4.5km, assume 0.5% of Everest population density for the sticks, i.e. 25000 dwarfs per cubic kilometer, and put it all together for a grand total of 69 billion Himalayan dwarfs.

Ubuntu 10.10 nits

Nice fonts.
Nice boot screen.
Nice boot screen doesn't work with fglrx.
Dark theme bg & window style screws up labels with dark text.
Dark title bar & dark menu bar occasionally look silly with the light-grey window bg. Especially Firefox looks bad. The thing with dark bg themes is that the amount of apps designed to work properly with one is damn close to zero. (Hence, I suppose, the light-grey window bg.)
The active window titlebar gradient looks kinda sloppy. Ditto for popup menu gradients.
Flat window buttons walk a tightrope between sucking and being just boring.
GTK widget theme buttons are very nice.
Dropdown widget has the triangle vertically off-center by 1px?
The salmon active color in the widget theme is not very nice.
Scrollbar widget looks different from the rest of the theme and a bit weird. Exacerbated by rounded buttons but no alpha channel, so Firefox textarea scrollbar buttons look icky.
New Rhythmbox icon is nice.
Rhythmbox itself is still nowhere near Amarok 1.4.
Amarok 2.0 is still nowhere near Rhythmbox.
Gnome Terminal icon is vertically off-center in top panel.
Notification area in top panel looks nice with the monochrome theme.
App icons in top panel are too tall and look bad.
Weather applet rainy icon has a black border. Other widget icons (other weather icons too) don't have borders, making the rainy icon look out-of-place.
The speech bubble icon in top panel is one pixel too low (more like one pixel too high).
The networking applet icon is super-confusing. I keep looking at it and wondering "Wtf was that icon for again? Check updates? No.. oh right, networking."
The (very low-visibility) round corners in panel dropdown menus look nice. But suffer from lack of text padding.
Window title color is actually orange instead of dark grey (try Chromium with GTK theme).
1px wide window resize handles make me cry.
The purple color works surprisingly well.
Default desktop bg is nice.
Popup text labels have too little horizontal padding. Otherwise they look nice.
Date & time applet text has too little horizontal padding as well.
The panel applets have crap spacing so you need to manually move them around by a couple pixels to make the layout look less horrible.
PulseAudio is glitchy and the volume control does not work (you can only set it between mute, medium volume and super-loud volume, no low volume setting available).
The new fancy volume control doubling as a music player remote is nice.
udev screws up md RAID arrays by being clueless (starts only one disk of a RAID-1 -> stops boot process thx to unable mount disk & dirty array after reassembly -> need resync -> FFFFUUUUUUU. How about using mdadm -A --scan like sane people do?) [edit: mdadm -A --scan wants to have an md device name like /dev/md0 instead of /dev/md/MyRAID, I dunno if that sunk udev or if it's just doing silly things.]
Nautilus is slow so I very much try not to manage files with it (instead terminal for quick & programmable things, Filezoo for overviews and visual sorting)
The CPU speed indicator applet could show all the CPUs at once instead of requiring running several copies of it.
I don't get what the Social Networks thing does. It doesn't seem to do anything. Maybe that's what it does.
What is Ubuntu One? Perhaps these things should be explained as one starts them up?
Why is this Gwibber thing so slow? Or perhaps it just lacks a progress indicator, making it feel slow.
Evolution feels like a really fiddly and slow interface to Gmail.

I do really like it for the most part, at least after a year in Debian's permabroken Gnome-land. I'd use FVWM or something cool and edgy and configurable like that for window management but compiz no worky on non-retarded WMs and theming FVWM (while infinitely easier than theming metacity) is limited and painful. Not that I've done any theming for a couple years. Plus you don't have a nice GUI to make F1 start a new terminal (just a nice thousand-line config file).

Maybe there should be a WebKit-based desktop environment.