A few hours ago, my network at home went down so I found a use for that personal hotspot feature sooner than I’d imagined (I got the beta of the iOS release as a developer). It’s… fast. I’m actually not noticing a difference in the speed web pages are loading. And me and my wife are both using my iPhone 4 to surf.

The battery is plummeting though but I’m in the house after all. Just need to plug it in, but was interested in seeing just how much pressure this’d put on the little thing.

Still, way cool.

The ads in Gmail sort of figure out what you “want” and show you ads related to that. If you have an email discussion talking about wanting to get a new BMW, Gmail will show you BMW retailer ads.

So when I the other day got ads about “Chinese women wanting a man”, it got me thinking. For one, I have no interests in Chinese women, whether they want a man or not, and I haven’t been talking about Chinese women anywhere either. Except for the fact I write and receive emails in Japanese.

Then earlier today I got an ad which reassured me that, “there are plenty of reasons why you can’t get an erection”. I’m fine with the emails, really, but when this kind of shit appears as a “legitimate” ad, it’s annoying on a new level.

I wonder if Google ever realized that the better their “targeted ads” become, the more hated they will be, because as they start to “hit home”, that’ll trigger some very sensitive buttons with people.

I mean, if I was having erection issues, do you think I’d be thrilled and excited and grateful that Google blares it in my face? I’m sure I could google it on my own, thanks.

Whenever I go to vote, something inside of me is always different. The emphasis, or focus, is tilted toward something new each time. This time, unsurprisingly, it was Japan. I saw everyone around me who came to make their voices heard, however small, and I thought about the vote rate for Japan — something like 40-45% usually (it was higher last time, thanks to Obama, I suspect). I saw a mix of Swedes and foreigners around me all with their voting envelopes in their hands, and I felt a sort of wonder at how they cared when so many people who’d been born and raised here did not. Perhaps my time in Japan as a foreigner put more presumptions into my head than it discarded…

Whenever I go to vote — and I have, since I was allowed to, which puts me at #3 today — I go through this range of emotions which is different each time.

I feel intrigued, looking at those around me, wondering who’s with me and who’s against me, wondering what would happen if everyone suddenly started yelling out their choices.

I feel good, for actually giving a damn. Even if I don’t put a lot of faith into these politicians, I at least make a statement as to which one I think sucks the least.

I feel bad, for not knowing enough about the available parties. For not looking into, asking, scrutinizing agendas and watching debates they had going on TV*. I made my choice but it wasn’t a firm, absolute one, it was of the wavering kind. Perhaps it’s the times…

I feel guilty, because even though I do vote, I do so whilst in the aforementioned predicament, and I’m afraid that if those around me vote as “lightly” as myself, our democracy is pretty much a castle on a mountain of sand — a single tremor could send it sliding.

I feel moody, because of the times changing. My own views have changed radically, as have those of the world around me. The Social Democrats, my obvious candidate in the past, are struck from my list, possibly forever, at the very least until Thomas Bodström is removed. The Pirate Party is a joke, or I’d go “the responsibility-less route”**.

I feel uneasy. I mean, some fairly nutty parties have gotten a lot of support lately. I’d probably give up and move out of this country if SD got into the government***.

Regardless, I’ve at least performed my duty, if half-assed, as a believer in democracy.

—

(* from what it sounds though, the TV debates were fairly useless — a truckload of shitflinging, mostly)

(** they have “no views” on anything other than letting people download shit (and, they try to claim, “on privacy/integrity”).)

(*** SD = Sverigedemokraterna, a bunch of racist pigs who had something like 7% of people’s votes in a poll a couple of months ago. In Sweden, you need 4% or more to get into government, and in rare cases where the two major alliances (left and right) are very close, those 4% can give you a lot of control, because in essence, if left goes ‘yes’ and right goes ‘no’, you decide if the answer is yes or no (if you say yes, yes gets “48+4=52%”! If you say no, no gets “48+4=52%!”, presuming left and right had 48% each and you the remaining 4).)

One of the simplest ways of doing this is to simply scan for identical blog entries, or blogs which focus on specific content. The recipe is simple, and if done right, impossible to detect:

1. Find 2+ blog posts about “chocolate pudding”.
2. Grab a random comment from each post.
3. Post each comment as your own user to each other blog, so that each comment appears entirely new, and genuine.
4. Put your spam URL in URL field.

There you have it. The only thing that could spoil you is if you accidentally grab a random comment that itself is spam from somebody else.

The way to combat this is to start ignoring the content of messages. In email, in blog entries, everywhere. We need to just give up on the whole idea. Instead our spam filters look at individual sites point to in URLs provided by said spammers.

Because you know what? These sites look almost exactly today, the way they looked 5, 10 years ago. They’re identical, because once we’re “there”, we either close the browser or we fall for the trap. It’s incredibly easy to scan for general spammy crap, like “viagra” or “penis enlargement” etc. Basically doing it the way it’s been done all this time so far, but applying it to web sites rather than emails or blog comments.

That’s all I had to say, really.

It reminds me of a talk at the Voices that Matter conference last month in Seattle, where Erik Buch talked about MVC, but also about his experience in the Aerospace software development field, where bugs must not be, and how the development strategies for this field differ greatly from those of e.g. games, where a crash will lead to a pouty kid or a drop in sales, at worst, rather than burning, stinking bodies splattered against the ground around a crashed airplane.

If you think about it, traveling thousands of feet up in the air across the globe is a rather extreme thing to be doing, if you don’t have wings to keep you up there, but we do it all the time. We’re at the verge of taking that step into space (which in some ways is less extreme than air travel), and I can’t help thinking what evolution can teach us about maintaining autonomous bodies with up-times that average 70-80 years (i.e. us humans).

In software development, we oftentimes streamline and optimize by ripping stuff out and “sharpening” the software to where it does everything it should with as little code as possible in as little time as possible, but nature doesn’t really think this way. Sometimes nature does the obviously taboo thing in software engineering, namely copy-pasting functionality around. It’s like a merging of the philosophies behind RAID and the philosophies behind optimized code. With millions of years of experience, our Great Programming Mother has made some very curious design choices, and all of them have been extensively unit tested and thought through by changing fractions of the code, testing it extensively, discarding failures, and keeping successes. Very similar to how software developers write code, just infinitely more thorough, and over a much greater span of time.

Nature takes things into account at a far greater scope than we do. For example, let’s say we have code in an automatic sliding door. The code does 4 things: it detects movement on either side (A), it opens the door (B), it waits (C), and it closes the door (D).

• For this code, we have 2 sensors (one on each side of the door) for motion. We code these sensors to call up “B” (open door) whenever we detect movement.
• We code up “B” to open the doors wide. When “B” is done opening the doors, “B” then calls up “C” (wait).
• We write “C” to wait for X amount of seconds and then to call up “D” (close the door).
• We finally code up “D” to close the doors.

When we try our door, with the wait time set to 3 seconds, we realize pretty quickly that if two people walk through the doors with only a few seconds in between, person #2 will almost get the door in their face, so we tweak our code a little.

• In “B”, we open the doors if they’re not open already. If they are open already, we call up the new “E”.
• “E” we code up to reset the timer in “C”. Thus, every time someone triggers the motion sensor on either side of the door, the 3 second timer is reset.

And there we have a human engineered sliding door in operation. Now there’s one very distinct thing we’re doing here that nature oftentimes does differently: we presume that it works.

A lot of code that we write, we write with the following notion in mind: I have to take every scenario into consideration, and have to account for every possible thing that could happen, and to deal with that in a good way in my attempt to perform “X“.

But nature’s code works on a different methodology — it goes something like this: I am trying to do “X“, and it might fail or it might succeed.

Nature works based on a fire-and-forget philosophy, where the reaction to situations is much more “lazy”, while being infinitely more flexible. The downside to nature’s approach is redundancy. Nature copy-pastes code all over the place because it has to. It has to double- and triple- and quadruple-check to see what’s going on, because it discards the idea of guarantees of success.

In the above sliding door code, nature would have most likely made a lot of different choices on the implementation. Fewer presumptions on what works and what doesn’t, and more redundancy to cover up for potential failures.

In regular software engineering (not the aerospace software kind), the place where our code looks the most similar to nature’s code is in initialization routines. Take for example this very simple example, where the sound card, graphics card, joystick and keyboard modules are initialized for a game system — emphasis on the concept, not on the (bad) code example:

int error_code;
error_code = sound_init();
if (error_code != ERR_NONE) {
  alert_user("Sound initialization failed! Check your sound card settings. Sound has been disabled. (internal error code = %d)", error_code);
  sound_enabled = false;
}

error_code = gfx_init(true); // true for hardware accelerated graphics
if (error_code != ERR_NONE) {
  alert_user("Graphics initialization failed! Check your graphics card settings. Software rendering enabled. (internal error code = %d)", error_code);
  error_code = gfx_init(false); // false for software renderer
  if (error_code != ERR_NONE) {
    alert_user_and_exit("Graphics initialization failed, again! We can't even do software rendering. Aborting! (internal error code = %d)", error_code);
  }
}

int use_keyboard = true;
if (setting_use_joystick) {
  use_keyboard = false;
  error_code = js_init();
  if (error_code != ERR_NONE) {
    // fall-back to keyboard
    use_keyboard = true;
  }
}

if (use_keyboard) {
  error_code = kbd_init();
  if (error_code != ERR_NONE) {
    alert_user_and_exit("Keyboard initialization failed! (internal error code = %d)", error_code);
  }
}