The idea for this project began during a casual lunch conversation, where were wondering about how challenging it might be to build a virtual keyboard from scratch these days. That sparked my curiosity, especially since the ESP32-S3 natively supports USB OTG. I was eager to try it out for myself and see what was possible.

Choosing the Right Hardware

Before making any purchases, I watched a helpful video by Andreas Spiess that explores the different ways ESP32 controllers handle USB functionality (13-minute video: https://youtu.be/hJSBTFsOnoA?si=-KlphLdLC01w7r4N). Based on what I learned, I chose the ESP32-S3 DevKit. It comes with two USB ports and requires no soldering, making it ideal for quick experimentation.

When the board arrived, I decided to set things up using my old Windows laptop, now running Ubuntu. This way, if anything went wrong (and released the infamous magic smoke), I wouldn't risk my main machine. Plus, I prefer a setup that's easy to reproduce without specialised gear.

Installing the Arduino IDE

To keep things simple, I approached the setup as a new user would. I installed the Arduino IDE directly from the Ubuntu Software Center. However, my first attempt at compiling code resulted in a GLIBC_2.29 missing error.

After checking with ldd --version, I discovered that my system actually had a newer version of glibc (2.39) already installed.

Troubleshooting Installation Issues

Seeking a solution, I consulted Perplexity and tried running arduino.pip install --upgrade esptool, hoping it would resolve the issue. Unfortunately, that didn't work.

After several unsuccessful attempts to upgrade the snap versions, I decided to switch strategies. I removed the snap installation: sudo snap remove arduino

Then, I downloaded the Arduino IDE AppImage from the official documentation and installed libfuse2 as recommended.

Flashing the ESP32-S3

With the IDE up and running, I asked an LLM for an example sketch to send "Hello World!" as keyboard input to any connected computer. After selecting the appropriate port, I flashed the code, connected the second USB cable, and waited five seconds. Sure enough, the device typed "Hello World!" virtually, just as expected.

Here's the code I used:

#include <USB.h>
#include <USBHIDKeyboard.h>

USBHIDKeyboard Keyboard;

void setup() {
  USB.begin();
  Keyboard.begin();
  delay(5000);
  Keyboard.println("Hello World!");
}

void loop() {
  // put your main code here, to run repeatedly:
}

Conclusion

This simple experiment opens up a world of possibilities. With an ESP32-S3, you can create your own stream deck, game controller, or even a custom keyboard—all without complex hardware modifications.

So how do you generate a white QR code with the rest being transparent without needing to sign up to a website?

Use qrencode and ImageMagick on the command line.

First, install the applications using:

brew install qrencode imagemagick

Then, generate the QR code:

# Create the QR code (white on black).
qrencode -s 20 --foreground=ffffff --background=000000 -l H -o "URL.png" "https://gestempelt-und-gedruckt.ch/"

# Replace black with "transparent".
convert URL.png -fuzz 10% -transparent black URL_transparent.png

I'm started off with a board from AliExpress containing a DHT22 temperature and humidity sensor with an attachable ESP8266 microcontroller.

Programming the ESP8266 microcontroller

To program the ESP8266 one needs an adapter (ESP-01 Adapter Board) which needs to be slightly modified with a button so that we can enable its programming mode (instructions).

Assembly

Having the parts ready I'm logging in to my Home Assistant and heading to the ESPHome view to add a new device. I create a new configuration and choose the ESP8266 as the device, then once it offers the "Install" option I insert the controller to be programmed into the adapter board, keep the button pressed and plug it into one of the USB ports of my Raspberry Pi running Home Assistant. Once plugged in I release the button again. At this stage I can then click the option to install the first version of ESPHome onto the controller via "Plug into the computer running ESPHome Dashboard" (be aware that this might take a while as it has to fetch dependencies and compile the custom build). This step will flash enough for the controller to be able to connect to the Wi-Fi and be updatable via ESPHome running on Home Assistant. It's important to note that the Raspberry Pi likely won't have enough juice to start the controller and hence it won't be doing anything after being programmed.

At this point I disconnect the programmer, take the controller out of the adapter, connect it with the board containing the DHT22 sensor and feed it with 5V from a power supply. One should see 2-3 LEDs light up. Shortly after the new device should appear as connected in ESPHome at which point the configuration of the device can be extended with options to tell the controller what kind of sensors are connected and with what kind of name it should be reporting the values to Home Assistant.

sensor:
  - platform: dht
    pin: GPIO2
    model: DHT22_TYPE2
    temperature:
      name: "Balcony Temperature"
    humidity:
      name: "Balcony Humidity"
    update_interval: 60s

Once added, save the configuration and click the "Install" button to remotely update the configuration on the device via the wireless connection. If you look at the logs of the ESPHome component for about 60s it should eventually log the temperature and humidity it just collected via the DHT22 sensor.

[13:13:26][D][dht:048]: Got Temperature=15.5°C Humidity=80.3%
[13:13:26][D][sensor:093]: 'Balcony Temperature': Sending state 15.50000 °C with 1 decimals of accuracy
[13:13:26][D][sensor:093]: 'Balcony Humidity': Sending state 80.30000 % with 0 decimals of accuracy

At this point I knew that the components and network connection worked as intended and that I can continue with the integration of it into the case. For the case I've used a modified version of Andreas Spiess's configurable 3d printable box with an arm that ensures the DHT22 sensor is far enough away from the controller and power supply to not be affected by it.

The case requires the DHT22 to be de-soldered and extended which is a bit finicky.

After a bit of fiddling this is the end result just prior to clicking the box shut.

I've used some double-sided tape to fix the boards to the case, used a cable tie to ensure the power cord isn't pulling too much on the power supply and finally used some heat shrink tubing for the sensor connections just to be on the safe side. Worth noting, while I did write that this sensor goes onto the balcony, it's not intended to be operated in a wet environment as both the sensor is exposed and the 3d printed case isn't waterproof.

There are a lot of great talks by Sam Aaron the creator of Sonic Pi on Youtube but I like this one quite a bit.

So while I was sitting there with my glass of Port working through the Sonic Pi Tutorial I had the urge to gain back my text editing fluency I'm used to from my day job. Luckily Sonic Pi supports a lot of keyboard shortcuts however as of now they're optimised for a keyboard layout of the english language.

After a bit of tinkering and the help of Karabiner-Elements I managed to re-map my line-commenting shortcut of CMD+Shift+7 (I'm working on a MacBook with a Swiss German keyboard) to the shortcut defined by Sonic Pi M-/.

The configuration you'll want is:

{
  "title": "Remap CH comment combo to EN comment combo",
  "rules": [
    {
      "description": "Remap CH comment combo to EN comment combo",
      "manipulators": [
        {
          "conditions": [
            {
              "bundle_identifiers": [
                "net\\.sonic\\-pi\\.app"
              ],
              "type": "frontmost_application_if"
            }
          ],
          "from": {
            "key_code": "7",
            "modifiers": {
              "mandatory": [
                "left_command",
                "left_shift"
              ]
            }
          },
          "to": {
            "key_code": "keypad_slash",
            "modifiers": [
              "left_command"
            ]
          },
          "type": "basic"
        }
      ]
    }
  ]
}

If you also got this need then following these steps should set you up.

1. Install Karabiner-Elements
2. In your terminal go to ~/.config/karabiner/assets/complex_modifications
3. In there create a file remap_ch_comment_combo_to_en_comment_combo.json and fill it with the configuration above.
4. Then start Karabiner Elements, go to the Complex Modifications tab and there click the Enable button for the new configuration .

Buildpacks

First we have to change the currently used buildpack to the multi buildpack which makes it possible to run the Node.js besides the Elixir buildpack.

heroku config:add BUILDPACK_URL=https://github.com/ddollar/heroku-buildpack-multi.git

Then add the file .buildpacks with the contents below which will pull in the buildpacks and run their compile script. The buildpack listed last will hereby be used to run the application.

# .buildpacks
https://github.com/heroku/heroku-buildpack-nodejs.git#34cffc9b6397bc1ce97a4b5e911fa771fc4e7907
https://github.com/HashNuke/heroku-buildpack-elixir.git#36f2ff22d0236589256d9044091b950b7cc565d2

Compile the assets

Now that we have multiple buildpacks we need to tell the Node.js one to run the postinstall hook after all the dependencies are installed. Just add the scripts part to your package.json and you're all set for Heroku to run the brunch build command.

# package.json
{
  "dependencies": {
    ...
  },
  "engines": {
    "node": "~ 0.12.1"
  },
  "scripts": {
    "postinstall": "node_modules/.bin/brunch build"
  }
}

Parse the environment variable

When deploying the application to Heroku, the configuration variables will be exposed to the application via environment variables. For the database that means there will be a single String from which the username, password, host, etc. will have to be extracted. You could theoretically do that by hand defining those variables individually, however what happens if your database provider has an issue and suddenly decides to change the value behind your environment variable? - in order to avoid that, just put the code below in your prod.secret.exs file to help you split the configuration variable for the database.

# config/prod.secret.exs
defmodule Heroku do
  def database_config(uri) do
    parsed_uri = URI.parse(uri)
    [username, password] = parsed_uri.userinfo
                           |> String.split(":")
    [_, database] = parsed_uri.path
                    |> String.split("/")

    [{:username, username},
     {:password, password},
     {:hostname, parsed_uri.host},
     {:database, database},
     {:port, parsed_uri.port},
     {:adapter, Ecto.Adapters.Postgres}]
  end
end

Then instead of defining the arguments for your app separately, call the database_config function and you're all set.

# config/prod.secret.exs
config :yourapplication, Yourapplication.Repo,
  "DATABASE_URL"
  |> System.get_env
  |> Heroku.database_config

Run the database migrations

heroku run mix ecto.migrate

Since I'm pretty new to Elixir and even newer to the Phoenix Framework, this tutorial might lack some best practices, in which case please let me know so this post can be updated to reflect them.

1. Start by going into the Settings > Webhooks & Services view and add the HerokuBeta Service.
2. Create the app on Heroku via the command line heroku create myapp
3. Fill in myapp as the Name in the HerokuBeta settings view and leave GitHub api url empty.
4. Then for the Heroku token, you'll need your Heroku api token, which you get via heroku auth:token (eg. token123) and your email address you're using to login to Heroku (eg. hi@email.com). Then convert the two into a base64 hash for the Authorization header by issuing this command on a Unix system echo "hi@email.com:token123" | base64 (eg. base64-123).

    curl -X POST https://api.heroku.com/oauth/authorizations \
    -H "Accept: application/vnd.heroku+json; version=3" \
    -H "Authorization: Basic base64-123" \
    -H "Content-Type: application/json" \
    -d "{\"description\":\"direct token description (preferably meaningful)\"}"

1. For the GitHub token follow the instructions and head to https://github.com/settings/applications where you can click Create new token, then give it a name and leave the default settings before hitting Generate token. Then copy this token and fill it into the form.
2. Save the configuration with Add service.
3. I first thought the hook is already working, however it's only working with GitHub deployment events, which you can add by adding another service called GitHub Auto-Deployment.
4. Repeat step 5 to acquire a new GitHub token and add it there, save and from now on your automatic Heroku deployment should be fully working.

Personal NAS-es are quite handy, however their wide spread usage and the fact that people don't often check their system via the web dashboard makes it a perfect target for crackers trying to extort you for money or just using your machine to mine bitcoins for them.

In this case I had a DS213j delivered to me with SynoLocker on it. A malicious piece of code that encrypts all your files and holds them hostage until you give in and pay them what they ask for. Please don't ever give in. Just accept that your data is lost forever and you hopefully have a backup of it somewhere else, if not, now would be a good time to start thinking about one.

So on that basis, the fix is fairly trivial.

1. Open the lid and take out all of the drives.
2. Put one into a desktop computer or use a S-ATA to USB docking station to connect it to a working machine so you can format the drive with FAT.
3. Put the one drive back into the NAS and boot it up.
4. As soon as it's booted, reset it by taking a paperclip and pressing the reset button on the back for 4 seconds until it beeps. Release. Press again for 4 seconds until it beeps again for 3 times. This will initiate a restart.
5. Download the Synology Assistant and install it on your computer, then start it up.
6. If your NAS isn't already showing up, give it some time to finish the booting process and then click the search button in the Synology Assistant.
7. Double click on the entry for your NAS which will open a browser window.
8. Download the latest Diskstation Firmware (DSM) from the Synology Download Center and go through the questions in the browser.
9. Upload your firmware and let the NAS re-format your disk, then give it some time for it to re-install.
10. When all is done, format all the other drives with the same process you used for the first drive. Shutdown the NAS and put them back in. Restart and go into the Storage Manager > Volume where you can add the newly inserted drives to your volume. Once added it will take a while for them to be added and re-index, partitiend, etc., you can safely use your NAS from now on however.
11. Now you might want to re-add your video, music and photo folders. That's it.

On a further note, since crackers were able to get into your NAS once, I'd ask yourself whether you really need external access to it and otherwise make sure there are no ports being forwarded by your router. Also I recommend changing your router password, especially in case it's still the factory default one. If you really do need remote access, at least change the ports which are used externally, eg. map 3001 to 5000 internally.

Lastly, I've used automatic DNS updating services quite a bit too, however they could have been the enabling party for the attack. Once such a provider is compromised, crackers can check their attacks against all your ports which makes the previous advice in-effective. Since routers nowadays don't change their ip addresses that much I usually look up my home address via the GMail login history and use the naked IP. Less convenient, but more secure.

Hope this short summary helped during your reset and it's the last time something like that happened.

Last sunday I enjoyed watching all four Bourne movies including the newest one. Additionally I like the TV series Homeland and Person of Interest. However what is shocking to me, is that while those stories are just made up by writers, situations like those on TV actually occur in real life to people like you and me (well sort of). Algorithms decide whom to kill and drone pilots carry out the strikes like robots. Without formal charges. Without asking questions.

If you have two hours to spare I encourage you to watch the full length track of the #29c3 session entitled Enemies of the State in which the three Whistleblowers Jesselyn Radack (former ethics advisor to the Department of Justice), Thomas Drake (former senior executive of the NSA) and William Binney (former senior technical leader of the NSA) talk about what the government did to them while they played by the rules. Quite an eye opener.

During the last couple of weeks many have announced that they are moving away from Google Feedburner. The reason for this move, the Feedburner API will be shut down in October of this year, probably leading to a similar fate for the feed proxy parts serving this feed.

That means, if you are reading this and would like to do so in a couple of months then I encourage you to update the URL in your feed reader with http://philippkueng.ch/atom.xml.

Thanks guys, for being such great readers.

Ein Artikel der Sonntagszeitung zum Projekt Trainshare hat am Sonntagmorgen einen doch beträchtlichen Twitter-”Shitstorm” gegen die SBB ausgelöst. Als Beteiligter am Projekt möchte ich gerne schildern, wie es überhaupt so weit kam.

Der Hauptgrund für die Situation ist höchstwahrscheinlich ein Missverständnis am 30. März 2012: An diesem Datum fand in Zürich ein Open Data Hackday statt, ein Anlass an dem Programmierer, Designer und andere mit offenen Daten an tollen neuen Anwendungen für die Öffentlichkeit arbeiteten.

An diesem Event, nach einem vorhergehenden Blogeintrag, riefen Alain, Adrian und ich die Trainshare App ins Leben. Nachdem wir einen halben Tag daran gearbeitet hatten, setzten sich Bruno Spicher und Jean-Philippe Picard von den SBB zu uns, um mit uns zu diskutieren, worum es bei der Trainshare App geht. Ich erklärte ihnen ganz offen, was der Plan war und was unsere Beweggründe waren. Anschliessend liess uns Bruno Spicher wissen, dass sie “an etwas Ähnlichem” bauen, das im Herbst 2012 veröffentlicht werden solle. Diese neue SBB App werde gleich funktionieren wie die bestehende Gleis7 App, zusätzlich aber “CheckIns” erlauben. Tiefe “social media” Integration von Twitter und Facebook wurden weder im Gespräch erwähnt, noch gibt es derlei in der Gleis7 App.

Aufgrund der obigen Informationen beschlossen wir, die Trainshare App weiter zu entwickeln, und den Pendlern als kostenloses, werbefreies “social travel” Experiment anzubieten. Die anfallenden Daten wollten wir aufbereiten und visualisieren, sodass den SBB indirekt ebenfalls ein Nutzen erwächst – neben zufriedeneren Kunden vielleicht gar mehr Fahrten.

Über den genauen Inhalt der damaligen Gespräche besteht heute Uneinigkeit, rekonstruieren lässt sich die Sache kaum. Was ich aber tun kann, ist, die Geschehnisse nach dem Hackathon im März bis zum Sonntagszeitungs-Artikel am vergangenen Sonntag chronologisch aufzuführen – in der Hoffnung, dass sich daraus vielleicht etwas lernen lässt.

Chronologie der Geschehnisse

30. März 2012 - Hackathon
Nachdem wir uns unterhalten hatten, schrieb Bruno Spicher wohlwollend auf Twitter über @trainshare und erwähnte dabei Michael Rüetschli, den Projektleiter von @SBBConnect:

Interessante #trainsharingApp Idee von @philippkueng philippkueng.ch/trainsharingap… #makeopendata /cc @rueetschli

— Spicher Bruno (@brunospicher) March 30, 2012

1. April 2012
Da wir unser Projekt während dem Hackathon nicht beenden konnten, schalteten wir kurz danach auf trainshare.ch eine E-Mail Sammelseite auf, die bis heute 200 interessierte Nutzer umfasst.

11. April 2012
Die Swisscom berichtet auf ihrem Blog über das @trainshare Projekt. Dies provoziert wiederum 18 zusätzliche Anmeldungen, was zeigt, dass wir eine Nische entdeckt hatten.

14. Mai 2012
Erste Anzeichen von @SBBConnect gesehen durch einen Retweet von @rueetschli. Nebenbei, wir beide folgen uns schon seit ca. einem Jahr gegenseitig auf Twitter:

SBB.Connect coming this autumn #SBB

— SBB.Connect (@SBBConnect) May 14, 2012

18. Mai 2012
@SBBConnect ist ab jetzt nicht mehr nur ein Konzept, sondern wird gebaut. Hab mir damals nichts weiter dabei gedacht, da gemäss unserem Stand des Wissens @SBBConnect der Gleis7 App ähnlich sein wird, und wir mit der Twitter- und Facebook-Integration von @trainshare ein ganz anderes Publikum ansprechen werden:

Soeben die letzte Anforderung spezifiziert. Damit endet genau jetzt die 4-monatige Konzeptionsphase.#SBB #SBBConnect

— SBB.Connect (@SBBConnect) May 18, 2012

28. Juni 2012
Hatte die Ehre und präsentierte @trainshare an der OpenData Konferenz 2012. Das Medienecho war gross und somit sollten auch bislang OpenData-fremde SBB-Mitarbeitende von der App Wind bekommen haben. Ein "Hallo, wir machen exakt dasselbe. Ihr könnt euch die Zeit also sparen" oder "Hi, wir finden es toll, lasst uns das zusammen bauen" oder jegliche andere Signale seitens der Bahn bleiben aus.

19. Juli 2012
Danilo, ebenfalls ein OpenData Hackathon Teilnehmer wies mich darauf hin, dass die @trainshare App Konkurrenz bekommt durch @SBBConnect. Als ich daraufhin den Artikel der Bernerzeitung las und sah, dass die App der SBB ebenfalls eine Integration der Sozialen Plattformen anbieten wird, bekam ich einen Schreck, da es doch hiess, sie soll wie die Gleis7 App werden:

@philippkueng kriegt trainshare konkurrenz? :) twitter.com/rueetschli/sta… zeitlich könntest du sie allerdings schlagen!

— Danilo (@dbrgn) July 19, 2012

Darauf kontaktierte ich die Team-Mitglieder Adrian und Alain und fragte sie, wie sie zu einer Beendigung unseres Projekts stehen. Dies, weil wir in einer Konkurrenzsituation die SBB niemals werbetechnisch hätten überbieten können und es keinen Sinn macht, eine Plattform für bloss ein paar Nutzer zu unterhalten. Zudem konnte es aus meiner Sicht nicht darum gehen, sich gegenseitig zu bekriegen, sondern darum, der reisenden Community einen Nutzen zu liefern.

20. Juli 2012
Da ich noch nicht von allen Team-Mitgliedern eine Antwort hatte und selbst unschlüssig war, wandte ich mich an den Opendata.ch-Vorstand, mit bitte um Rat. In der Diskussion wurde immer klarer, dass eine harte Konkurrenzsituation kaum etwas bringen kann– wie einige Jahre zuvor die App GottaGo gezeigt hatte.

23. Juli 2012
Das Trainshare-Team fällte – auch aufgrund des Falles von GottaGo – den Entscheid, das Projekt stillzulegen. Aber auch es wieder aufzugreifen, sollte die SBB App nicht machen, was wir uns wünschen. Zudem beschlossen wir, uns den SBB zur Verfügung zu stellen und nach Möglichkeit mit unserem Fan-Feedback mitzuhelfen, dass die App das wird, was sie sein könnte.

25. Juli 2012
Am Abend telefonierte ich mit dem Journalisten der Sonntagszeitung, und schilderte ihm meine Sicht der Dinge. Dabei ging ich noch immer davon aus, dass uns im März nicht kommuniziert worden war, dass die @SBBConnect App “social media” Integration haben würde.

26. Juli 2012
Der Journalist kontaktierte anschliessend auch Bruno Spicher von den SBB, um dessen Sicht der Dinge einzuholen. Da alles mit dem Gespräch im März begann, trug mir Barnaby Skinner danach die Worte von Bruno Spicher vor, um allfällige Diskrepanzen mit meinen Äusserungen zu finden. Dabei hiess es, Bruno Spicher habe mir gesagt, die SBBConnect App werde ähnlich der Gleis7 App werden, CheckIn Funktionalität sowie Social Media Integration bieten.

Meinerseits erinnere ich mich lediglich daran, dass es eine Gleis7 ähnliche App mit CheckIn Funktionalität und Coupons werden solle. Nachvollziehen lässt sich das nun kaum mehr.

Und jetzt?

Sicher hätte man vieles anders machen können. Aber das hilft dem Projekt nun nur noch wenig, entsprechend können wir nur nach vorne schauen. Ich persönlich hoffe, dass die SBB Führung die negative Stimmung im Nachgang zum Sonntagszeitungsartikel nicht als Normalfall in der Arbeit mit offenen Daten ansieht. Ich würde mir wünschen, dass sich daraus Lehren ziehen liessen für mehr Offenheit, für mehr Plattformdenken, wie etwa bei den Verkehrsbetriebe von San Francisco.

In diesem Sinne bitte ich euch Blogger und Twitterer alle, mit dem Shitstorm gegen die SBB aufzuhören. Und die SBB bitte ich ihr Bestes zu geben, um die optimale Version der @trainshare Idee umzusetzen, eine echt innovative “social travel” App!

Zudem nehme ich die öffentliche Einladung von @rueetschli, dem Projektleiter von @SBBConnect, gerne an und komme ihn in Bern besuchen:

sonntagszeitung.ch/multimedia/art…Biete dem @philippkueng hiermit gerne an,uns in Bern zu besuchen,damit er weiter an @trainshare arbeiten kann @BarJack

— Michael Rueetschli (@rueetschli) July 29, 2012

Bezüglich den Lehren und einer Interpretation der Geschehnisse empfehle ich den Artikel von Hannes Gassert auf dem OpenData.ch Blog.

Last week I was priviledged to talk about @trainshare at the second OpenData conference in Switzerland. I was truly honored, and therefore nervous, to present after great speakers like @hannesgassert and @rufuspollock.

Basically I wanted to give the attending journalists and politicians an overview of what it means to develop a project based on OpenData or for that matter OpenGovernmentData. That getting Data for free does not mean the service has to be free too.

For those who have not been able to attend, or just want to glance through the talk again, @AdrianKuendig (working on the Windows Phone App for @trainshare) was kind enough to record it.

Thanks for the amazing opportunity @BarJack, @hannesgassert, @andreasamsler, @loleg, @ecolix and the rest of the OpenData.ch team.

It has been quite a while since #MakeOpenData took place, the event where trainshare transformed from being purely an idea to something more tangible.

Since @AdrianKuendig, @visualcontext, @koma5 and I were not able to deliver a running prototype until the end of the event, we continued working on the App as well as the API whenever we had some spare time. While it is neither done nor available in the AppStore yet, we just wanted to give you a sneak peak of what is to come.

As you can see, from the video above, there are still things need to be figured out or refined. While we might think of some ourselves, we always welcome your suggestions, so do not hesitate.

Well that is it for this time around, thanks to my trainshare team members, the awesome guys behind #MakeOpenData who made this event possible, journalists and bloggers who wrote articles like this, this and this. You rock!

Socket.io

Abstract - It's a Javascript wrapper library written for Node.js which makes the usage of websockets a lot easier. It also takes care of supporting older browsers with multiple fallbacks. By using socket.io, creating "realtime" applications is a matter of minutes.

Meteor

Abstract - Meteor is an opinionated toolset of common Node.js npm packets and some custom code. Among many things it enforces the use of Fibers, Socket.io and MongoDB both on the server aswell as on the client side.

Here is some explanation on what I said during the talk for those who were not present. I am well aware that I did not sell Meteor as the next big project that everyone has to pick up. The reason is simply that it is really in its early stage of development. Additionally I think it is rather dangerous to sell Meteor as a framework for beginners, since its magic bits hide a huge amount of logic a beginner normally does not need to use in order to build a hello world application. By embracing Meteor the novice programmer does not learn anything about those hidden areas which probably lead to unexpected results here and there. After all distributed systems are hard to build.

An example for such a use-case is the todos application which comes bundled with meteor. It is nicely done and quite easy to understand, but what happens for instance if 2 users, with a high latency connection to the server, update the same entry at about the same time? Your changes will be reflected immediately on your machine, with the syncing following a few seconds later, and a few seconds later from there you might be surprised to see that your original changes have been written over by the second user. With a traditional stack you would do some locking or at least insert versioned entries, but with MongoDB this is not supported by default. You would be able to implement versioning yourself by using timestamps and inserts for every update but why the additional overhead?

Just to state it again, the words above do reflect my personal experience when playing with Meteor 2 weeks after its initial appearance in April 2012, and I will be happy to give it another try once it has somewhat matured.

As for the @JSZurich event, thanks to @ikr for hosting us and @seldaek for organizing it.

My goal is to realize the backend as well as various mobile clients with the help of other hackers during the make.opendata.ch hackathon to show what can be done by leveraging publicly accessible data. And just for the fun of jumping on the buzzword bandwagon, it will be SoLoMo (social-local-mobile) ;-).

What led to the idea

Day in and day out I am commuting back and forth from where I live to Zürich. In order not to see those hours spent commuting as time wasted, you will have to spend it wisely which often times means doing some kind of work. For a programmer that is a piece of cake ;-). However there are times you just want to talk to someone remotely familiar. You could obviously do some kind of creepy stalking and wait outside the train until the very last minute before departure to see if you see someone you know. Chances are you will either find no one or they actually want/have to do work instead of chat with you. So status quo sucks, right? Well could we improve it?

The idea

Obviously yes. Let us create a mobile app that allows to checkin to a train and then find conversation-partner-matches via Twitter, Facebook and maybe even Foursquare.

The User Interface

When starting the app for the first time you are using one of those buttons on the login screen to connect to your favourite network and start using the TrainsharingApp.

The subsequent window you will get is the home screen on which you can enter your commuting route. This will make a call to sbb.ch to get the timetable and save it locally for later reuse. If you have already used this route there is a quick dial button to select your route and then select the departure time on the following view.

As soon as you have chosen a time, you are automatically checked in to that train-route which will trigger a push notification to users on the same train or users who will share part of your route and with whom you are friends on one of the social networks offered at login. After sending those notifications to friends or receiving one you are able to initiate a Meetup by selecting their name, selecting optional information and tipping the "Meetup" button.

The Technical Implementation

As for the backend, there exists an already scraped static dataset of train lines with their corresponding numbers, eg. S8 18898 and each route (Station to Station, see below). All in all about 230'000 routes which will reside inside a MySQL DB. In case you want to play around with the dataset, here is a routes table dump.

|id|linename|dep_station|dep_time|arr_station|arr_time|
|:-|:-------|:----------|:-------|:----------|:-------|
|1|S2725920|Waldshut|06:24|Koblenz|06:29
|2|S2725920|Koblenz|06:44|Klingnau|06:47

For matching friends there will be some kind of NoSQL DB instance since MySQL is not that good at it without creating a lot of table and row overhead. Still needs to be figured out, suggestions are welcome.

Additionally there will be a join table (routesusers, see below) for matching the routes with users. Since the routesusers table can fill up quite fast and past data does not need to be held warm, it will be pushed to S3 for later analysis and then cleared every 24 hours.

|id|routes_id|users_id|start_time|
|:-|:--------|:-------|:---------|
|1|423|234412345|12:03
|2|5122|967512345|14:34

So much for the storage part, now over to the API. There will be three endpoints at least, /login, /checkin and /read.

/login will be used to send the social network authentication tokens over to the server to allow us to do the bandwith heavy parts. The request should be one of type POST with the credentials in its body, which will give a trainsharingID back as a response. This trainsharingID will then be stored on the client device and used for every single request as a querystring.

|Key|Value|
|:--|:----|
|network|facebook, twitter or foursquare
|token|network_token
|token_secret|network_token_secret

/checkin is, as the name suggests, the endpoint for when a user wants to check in to a train ride. For clarification, a train ride consists of multiple routes (Station-to-Station) and may also involve switching trains. Requests to /checkin should also be of type POST with the trainsharingID in the URL as follows /checkin?trainsharingID=your_trainsharing_id. As for the POST body, it is the information getting delivered when clicking on the details section for the specific connection timetable on sbb.ch.

|Key|Value|  |Key|Value|
|:--|:----|:-|:--|:----|
|dep_st-1|Siebnen-Wangen|  |dep_st-2|Pfäffikon SZ
|dep_t-1|06:03|  |dep_t-2|06:19
|arr_st-1|Pfäffikon SZ|  |arr_st-2|Zürich HB
|arr_t-1|06:13|  |arr_t-2|06:48
|train_id-1|S2 18220|  |train_id-2|IR 1754

/read will be the only endpoint accessible via a GET request, though it still needs the trainsharingID in the querystring. /read is for manually asking if new overlaps have been found since checking in. The goal however should be that this endpoint is only used for development and new overlaps are sent to the user via PUSH notifications in a production setup.

Enough with the server stuff, what happens on the mobile? -Well, upon first launch of the app the user signs in with one of those social networks which will create an OAuth token and an OAuth token secret which will be sent to the /login endpoint mentioned above. The trainsharingID in the response then gets stored persistently in the application storage.

Next up is the home screen where the user can enter departure and arrival destination to look for available trains. This will trigger a POST request to sbb.ch from the phone, parsing the response and showing the available options to the user. If a user selects a specific time another GET request will be fired to fetch the details information for that connection whose response gets parsed and sent to the /checkin endpoint.

If matches already exist, the response to the /checkin POST request will contain users from various networks who are matching the friends criteria. In case none exist yet the response will be empty. In both cases the user will be notified via PUSH if additional matches are made later on.

Both a proper UI and API endpoints for the meetup functionality still need to be figured out. Maybe it even makes more sense to use their native networks eg. Facebook or Twitter for messaging instead of building yet another Whatsapp clone.

Well, that is all there is to say about the TrainsharingApp at the moment. Have I missed something? Or do you have a specific suggestion concerning changes, additions, or removal of features?

In case you are interested in creating a native mobile client besides the one for WindowsPhone, which is already being covered by Adrian, let me know either via twitter or the comments below so I can get in touch with you. The same goes for designers too.

Below are the recordings of last week's joint event by the IT geeks Zurich and GTUG Zurich. At this event Luuk van Dijk a staff software engineer at Google who's currently working on the Go compiler and Johan Euphrosine a Developer Programs Engineer working on App Engine offered some insights on how Go can be leveraged and what it does internally to do so.

Also many thanks to the organizer Muharem Hrnjadovic for making this second amazing IT geeks event possible.

And without further ado, enjoy the talks below and excuse the Pizza distribution dilemma we luckily had to deal with.

OpenData, BigData, Infographics, Visualizations and Data journalism are all buzz words and movements which started to get quite some traction lately.

Whilst there are lively ecosystems of blogs around niche topics like visualizations, processing or data journalism there is not enough interdisciplinary communication going on in my opinion.

Well, how about creating it by interviewing those experts, giving them some airtime and maybe even connect previously unknown scientists, journalists, hackers, politicians and ideators to each other.

Since I am still toying with the idea there is nothing fixed just yet. The language might be English or German depending on who is in front of the camera. Also if you are interested in being a host or can suggest a person, let me know.

Would you like to listen to or watch it?

One needs to be able to recognize and commit oneself to tasks with inflated importance and unreal deadlines, while making oneself feel that they are important and urgent.

Positive side effect, you're able to work off those items quite relaxed. On the other side you might also over-commit to incoming work because estimating white noise is kind of difficult.

On another note, have a look at the awesome copy in the article footer. Brutally honest.

More about the goals and mindset of OpenData.ch can be found in the German-Only - Open Government Data for Switzerland Manifesto.

If you're up to create something with OD, whether your a developer or not, reserve march 30th and 31st when the next Make.opendata.ch-Hackathon will be held. Need, some inspiration of what the first one was like? Checkout the great summary by datavisualization.ch or read my hackathon review.

Thrilled to start this new chapter with an amazingly diversified group of people.

Be widely read. There are endless books about architecture, books by naturalists, both classic and popular modern novels, and most of them have absolutely nothing to do with computers or programming or science fiction.

via the codeproject newsletter

We work in an environment where hearsay and taste drive change instead of studies and models.

Richard Minerich writes about the shift in programming languages away from proven ones to scripting languages. I tend to agree that dynamic languages should mainly be used as glue. Building a house out of porous cardboard could work if you're an experienced professional, but it'll probably fail for most of us. That said most of my code to date is dynamically typed because it's just way too comfortable.

However there's no test that'll cover every single error case on the other side there always will be static and correct formulas.

Maciej Ceglowski:

I love free software and could not have built my site without it. But free web services are not like free software.

Now after having migrated this blog over to a static version I needed a replacement to enable visitors to send me e-mail while at the same time not opening the doors for spammers. PHP scripts can easily fulfill that job but I want something else.

While having used the free version of Wufoo in the past I thought it's a no brainer to go back and leverage it again. Obviously paying for it this time. Then it hit me while checking the pricing page. The cheapest subscription is 15 dollars per month, while free plans are displaying ads to your visitor. What are they thinking! Paying 15 dollars, which is more than I pay for hosting, while only receiving about two messages during that time period.

That said, please startups and SaaS companies, remove the free model and make premium reasonably priced.

As for Wufoo, i'd guess replacing the free plan with one where you'd pay 2 dollars a month would make them more profit than showing ads on those confirmation pages.

When talking about showing ads to free users checkout the tweet by @romeroabelleira and give it some thought (translated):

Dear Advertisers on Spotify, I don't even pay for Spotify, I'm therefore worth nothing to you too. Sorry, Juan

Dslrnewsshooter video: Nikon D4 - video feature run through from Dan Chung on Vimeo.

The most innovative feature in my perspective however is the Ethernet connection and what comes with it, a camera management console completely built in HTML and JS so one's finally able to leave all the proprietary, heavily bloated, vendor specific crap software behind and focus on realizing ideas.

Checkout the video WHY by Corey Rich below if you want to see what's possible with a D4 presumed you know what you're doing.

WHY - Nikon D4 Release Video from Corey Rich on Vimeo.

Right now I've already broken most of my New Years resolutions, I admit it. Why? - Well, I thought of me as a machine, meaning that I could easily deliver one hundred percent without an issue. In fact, that's extremely unlikely to happen and I obviously knew that but I still made that promise with myself, you need to aim high right?. However, the impact it has by breaking resolutions or not reaching your goals makes you feel terrible or worse even makes you feel sorry for yourself. That's why I recommend you watch this excellent talk by Tony Schwartz and start correcting your self expectations by stop wanting to prove yourself to others or yourself. It's good to have goals but a weekly to do list has nothing to do with dreams just doable tasks.

via swiss-miss

While I'm not sure yet if I'll ever do the same, I started wondering on how to realize something like a Link-Blog with Octopress. Turns out it's pretty easy.

First modify the article.html inside source/_includes and exchange the lower <h1> part which is responsible for the page view title with an if-else clause.

<h1 class="entry-title">
  {{ "{% if page.ref_url" }} %}
    <a class="reference" href="{{ "{{ page.ref_url" }} }}">{{ "{{ page.title" }} }}</a>
  {{ "{% else" }} %}
    {{ "{% if site.titlecase" }} %}
      {{ "{{ page.title | titlecase" }} }}
    {{ "{% else" }} %}
      {{ "{{ page.title" }} }}
    {{ "{% endif" }} %}
  {{ "{% endif" }} %}
</h1>

Then continue with adding an if-else clause to the atom.xml file too. Extend the <link> element inside the parent <entry> with the code below. Done.

{{ "{% if post.ref_url" }} %}
  <link href="{{ "{{ post.ref_url" }} }}"/>
{{ "{% else" }} %}
  <link href="{{ "{{ site.url" }} }}{{ "{{ post.url" }} }}"/>
{{ "{% endif" }} %}

If you want to create a Link-Blog post now, add ref_url to the markdown file header and Octopress takes care of the rest.

{% highlight text %} Title: This Awesome Article" date: 2012-01-13 21:20 Comments: true ref_url: https://somesite.com/thisawesomearticle.html This one is really great, check it out. {% endhighlight %}

Alternatives

If Jekyll is too nerdy for you, then please checkout tumblr whose philosophy has been based on link-blogging for ages.

On the otherside if Octopress and therefore Ruby is still to cool for you to use then give the newly released Second Crack by Marco Arment a try. It's also baking your markdown files to flat html ones, but it's written in PHP.

(Sidenote: PHP and I were never really friends)

Getting the "old data"

Log into your BlogEngine site and head over to Settings where you click on the Export button for BlogML. Now FTP or SSH into your server and get a complete dump of the App_Data/files folder onto your local machine.

Setup Octopress

Octopress? - Isn't this tutorial for Jekyll? - you might ask. Well Octopress is built on top of Jekyll and brings some plugins and clever defaults to make your life easier. Start off by following the official Octopress Setup tutorial. If your working on an OS X machine you might want to consider installing POW since it's making it much easier to work with Jekyll locally. Once POW is installed open your Terminal and go to ~/.pow and create a symlink to the octopress-repo root.

$ ln -s /Users/yourUsername/Documents/octopress myapp

Now open http://myapp.dev in your browser to check if it's working so far.

Import the "old data"

Create a folder _import inside the octopress/source directory and put the blogml.rb conversion file in there.

$ cd octopress/source
$ mkdir _import
$ cd _import
$ wget https://github.com/philippkueng/philippkueng.github.com/blob/30ef1570f06d33938b18d5eee7767d6641b9a779/source/_import/blogml.rb --no-check-certificate

This import script was actually created by @derekmorrison to assist him by Moving to Jekyll. Since URLs have to be rewritten because of the .aspx extensions which are part of BlogEngine I slightly modified the script to additionally create an .htaccess file and to play nice with non-ASCII encoded post-titles.

Next, move the BlogML.xml file inside the source directory and also create two seperate folders called files and images inside source. Then copy the contents of the previously dumped AppData/files folder to their respective folders (images or files) by keeping the path structure intact. Means, that AppData/files/2010/2/file.zip will go to octopress/source/files/2010/2/file.zip.

Now to the fun part, open your Terminal and navigate inside your octopress/source directory. Then execute:

$ ruby -r './_import/blogml.rb' -e 'Jekyll::BlogML.process("BlogML.xml")'

This should have imported all your existing posts so that you can now generate your Jekyll blog from it by exiting the source directory and issuing the rake command.

$ cd ..
$ bundle exec rake generate

Deploying

There's already documentation available on how to deploy Octopress to various hosting platforms. Since you're migrating from BlogEngine I highly recommend running your own VM or getting a shared hosting account with .htaccess support in order to not let your visitors down with feeding them broken links. Actually since Heroku is offering their polyglot Cedar-stack you should be able to run .htaccess on there too. YMMV

If your hosting provider is only offering FTP, then deploy manually by uploading the contents of the public folder and adding the .htaccess file from inside the source folder.

Fixes

We're not quite done yet. Log into your Google and Bing Webmaster account and replace the sitemap.axd entry with sitemap.xml. The same goes for your Feedburner account, log in and replace feeds.axd with atom.xml.

Finally fix the disqus comments. Log into their dashboard and select the account you want to migrate. Then click on the Tools tab and afterwards the Migrate Threads navigation entry. Hit the Start Crawling button for the Redirect Crawler Migration and your done.

Update - 14th april 2014

Eric Duncan migrated his CommunityServer blog to Jekyll too by modifying the BlogML import script (see comment below). For further details on how he did the migration, head on over to his blog where he also provides a couple of ethical reasons why one should move to a public and versioned blog.

A few days ago a fellow blogger nearby, Sam Steiner, was giving away a startup idea. The goal would be to develop a web platform where upcoming parents can write and design birth announcement letters which will then be sent out through the company as soon as the parents complete the information for example with a picture upload via their mobile. The sending for the inner circle will then be made by sending physical cards whereas the rest will receive a nicely formatted email or facebook wall entry.

After reading his idea I immediately responded via a comment that he should make it happen, after all aren’t those the successful startups that fullfill an itch that a founder has himself?

Throughout the rest of the day my brain was occupied by coming up with ways to turn this idea into reality, thinking about partners in the printing business who would send out the printed goods and maybe also pre-fill them. What might their pricing requirements look like? - after all their struggling themselves in the world of the internet. After the physical side was mentally figured out the question was how to build the website? - which technology stack to use? - hacking it together over a weekend? - with whom?

Later that day I told my father, a non computer savvy person, about that great idea I saw on the internet today. He was looking at me as if i was out of my mind. He totally disagreed and instead suggested that women, in the week prior to giving birth when being bored and at home, could potentially pre-write the letters so that the husband could then just print out the pictures stick them into the cards and then send them to friends and family.

After having the discussion with my father i think he’s totally right in terms of not outsourcing the bonding part with people you care about. It’s not about time you’d gain by using such a service it’s about openly investing yourself into the relationships to others by sending a handwritten card rather than wrapping your personal writing in an emotionenless off the shelf card with corporate branding on the back.

On a sidenote to all developers, I know it’s all too easy to get stuck in the optimization trap without knowing it. We tackle the market analysis with the identical mindset as writing revision one of the service. The approach might work in an emotionless business area but is certainly not suited at all for private relationships. As a hint, talking to people with different backgrounds helps enormously.

In an effort to make the world a better place, hackers all around Switzerland joined this years make.opendata.ch hackathon in Zürich and Lausanne. The goal was to use publicly available data, so-called OpenData and visualize it in a meaningful way so everyone is able to make sense of it.

Despite of having a french language deficit - it was a dark chapter in grammar school - i travelled all the way to EPF Lausanne which was absolutely worth it.

After the kickoff Florin, Frederic and I immediately started working on a project to improve the routes suggestion of traditional mapping applications such as Google Maps and OpenStreetMap by providing a way to add obstacles to a map and then calculate a new obstacle-free route to help people on tight schedules arrive on time. While we knew that large companies are working on that we were still looking for a hack to finish something usable until the deadline the day after.

The theoretical solution - The frontend would be a static website where the user can enter departure and destination location. This then would make an API call to the backend where the hacks are doing its’ part. The backend would consist of a webkit process running, controlled by PhantomJS. If a request gets issued PhantomJS loads Google Maps Directions with the start and end location, let the server-side webkit process render the page and then add all the obstacles via Lat/Long with a predefined icon which is easily distinguishable from the map itself. Next, PhantomJS creates a PNG-screenshot of the obstacles and route containing website. It starts the next process which parses the PNG pixel-by-pixel and looks if there is a blue line and an obstacle crossing. If so, make a circle of 300m radius around the obstacle and randomly add a Lat/Long coordinate, being part of the circle border, as a waypoint to the routes call of Google Maps. Then repeat the process above to check if the new route interferes with obstacles. If finally and obstacle-free route is found, return the details to the frontend.

During dinner, about three hours in, we came to the conclusion that it is just too much of a hack to spend valuable hacking time on, so we had to find something more suitable for the next day. Which we did in SwissMap.

Full of vim and vigor we then started on Saturday morning, Florin by collecting the interesting data from all over the bfs website, Frederic by merging and crunching the data into a format which is then processable via Javascript and I took care of the view and the comparing alogrithm. We aimed at building a web application where citizens and data-journalists can compare two different, unrelated datasets and visualize the outcome on a swiss heatmap. Luckily our very intense and focused hacking on day two was enough so that we were able to meet the presentation deadline in the afternoon. Epic Win.

[ live, wiki, source ]

I hereby thank the sponsors, hackers and especially the team behind the MAKE.OpenData project Andreas, Hannes, Oleg, Antoine, François, Frederic and Jeremy very much for making the event possible and inspiring us.

Amazing MAKE.OpenData projects others have built

• green-street [ live, wiki, source ]
• gesagt-im-parlament.ch [ live, wiki, source ]
• politnetz visualization [ live, wiki ]
• Swiss Army Contaminated Sites [ live, wiki ]
• Where Did My Taxes Go [ live, wiki, source ]
• openletten [ live, wiki, source ]

Travelling is supposed to be relaxing right? However there are many things you need to take care of for example writing postcards, sending SMSes to loved ones and keep notes of all the sites, actually this time RL ones, visited.

While I did exactely that for my last vacation in Canada, we were handling it differently this time.

During the flight from Frankfurt to San Francisco we came up with the photoblog called sfo2yvr, which includes the airport code of SF and Vancouver in its’ name, creative we know. It is based on Jekyll rather than Tumblr, which we actually wanted to use in the first place. However, we needed a platform to publish articles offline and did not want to rely on third party apps like MarsEdit, with git and github pages that is cake.

The idea was to update it once a day, however because US National Parks mostly do not yet offer Wifi, nor electricity or running water (rivers do not count), we sometimes only committed to the local repository and pushed to github when we were in a peopled area later.

This technique for blogging worked pretty well for us so far, however I am really curious what others, maybe you, have done in terms of solving the offline problem or finding the suitable picture for the day.

Changing habits is difficult. On December 31 you think that in 201x you will stop smoking, start eating healthier food or in my case plain and simple gain weight. (yes, I want to be a sumo wrestler) The only problem is that you are currently within your comfort zone and you are not taking immediate action. You are procastinating. I guess a lot of people, me included, never get out of it and already fail before having started. A tip, which might sound weird, but has worked for me so far, stop thinking about it and put yourself in a position where “The only way out is through.” — Winston Churchill.

Then secondly as with every habit you want to adapt, it needs to be included in your daily routine. That means if you can keep a daily routine up for about three weeks you are most certainly going to succeed with making it a habit.

About four weeks ago my friend Steve, with whom I co-founded bitfondue, sent out a tweet which started a discussion between the two of us on how to simplify life by leveraging agile practices with the outcome that we agreed on producing a podcast about that. Still having the two points above in the back of our heads we skipped being procrastinating wusses and started being agile right away. We successfully recorded the first iteration, set up a blog using Jekyll (we are nerds what do you expect? Wordpress.) and registered the domain within the first week after initiating the adventure.

Enough history, now to the meat, if you want to have 30 minutes of LOL I highly recommend listening to Iteration 1 otherwise give Iteration 2 or 3 (the one below) a try. For more information, future iterations or comments head on over to agilelivin.

After writing the last post about the Lizard Brain I gave myself another episode of Back to Work it was episode number 4, and in there, at the end, Marlin Mann talks about the way he is handling Task Lists which mysteriously worked extremely well for me too.

It works as following, prior to adding a task to your list go mentally through it and notice every single subtask you need to achieve in order to check that item of your list. That way I accomplished 4 tasks which consumed about 2h of my time without really noticing it and that said those tasks were sitting on my list for 3 weeks already.

Next there is the second and last rule, do not dare to put tasks on your list you know upfront you are not going to do anyway. For me such a thing is sorting my photo library, I used to have an entry for sorting pictures taken while being in Canada (2008) on the list until very recently. By the way decluttering it regularly helps a lot too, believe me.

Today I was listening to Back to Work by Merlin Mann and Dan Benjamin while coding up the next Big Thing, at least that is what the Lizard Brain tells me. During the episode they were talking about excuses one might have for not shipping all those unfinished projects.

Among those things standing in the way of letting us succeed with our ambition is the so called Lizard Brain (Amygdala). According to Seth Godin it only cares about four things: food, reproduction, safety and of course itself.

So in order to satisfy the Amygdala one has to minimize risk which is not really arrangeable with having a startup or generally learning new things because leaving our comfort zone is always a part of making progress.

Like with every other unwanted behaviour applying the principle of classical conditioning to ourselves might do the trick. In order proove my theory of Lizard Brain-self-conditioning right or wrong I am planning to work with it during the next month, constantly placing myself in unknown or personal flight-situations.

As far as I know it takes about three weeks to get used to something, so the last week should then be pure productivity and joy without procrastination and anxiety. I will let you know if it worked out until then wish me luck. (for the last part, that was clearly the Amygdala speaking ;-)

Last night I had the task to fix a clients custom built website which I wrote quite a while ago on top of an early version of hammyoncoffeine.

Nothing difficult you might think, in the end I should be familiar with it, additionally I was using Version Control which were even better preconditions. So I thought.

Fact is, the date of the initial commit lies about half a year in the future from the date I actually needed.

Luckily I was playing quite a bit with Backup Tools at that time so going through the zip-archives on Wuala should bring the piece of code to daylight.

Sadly I only compressed ready-to-deploy pakets and yes they're are already compiled. So much for that.

In the end I had to apply non-DRY ducktape patches to meet the deadline, nonetheless I learned a valuable lesson that night, commit early and often (even when working on seemingly unimportant files).

Lately I’ve gotten several E-Mails a day from monitoring sites that look after my websites hosted on Genotec containing messages like “you’re site is down”.

So migrating to another hosting provider was the obvious way to go, however since there’s no other Shared-Hosting company in Switzerland, that I know of, offering .NET hosting I decided to go the Open Source route and run BlogEngine on Ubuntu.

While I wasn’t able so far to get the most recent release, version 2.5, to run on Ubuntu I simplified the installation process for doing so with release 1.6.1 by writing a script so that everyone should be able to install it themselves.

Now to the installation process. Take a clean install of Ubuntu 10.04 LTS either running in the cloud or virtualized on your local machine.

Then go through the steps below to execute the BlogEngine.NET installation script.

# Login to your VM.
ssh your_username@your_ip

# Gain root privileges.
sudo su

# Go to the root home directory.
cd

# Download the BlogEngine.NET install script
wget http://bit.ly/blogengine_install

# Set Execute-Permissions on the install file.
chmod +x blogengine_install

# Start the setup by executing the installation script.
./blogengine_install

You should now have an Ubuntu sever running BlogEngine. To validate that it’s actually working start your browser and enter the VMs IP.

# Command to get the VMs IP when logged in to the server.
$ ifconfig eth0

Congratulations on not relying on proprietary software anymore.

Most people use a blog to build up a personal brand for whatever reason. Having profiles on various networks (social or not) might help multiplying the impact, however doing so doesn’t make you any more credible and in the worst case just pollutes the internet, maybe even weakens the goal you’re aiming for.

Every network is good enough on its own, so while mixing them might make sense in terms of amplification, connecting them should be used carefully and in no way continuously. Really, please don’t do this.

In order to comply with my statement above, and because I got sick of the old design, I slimmed down my blog drastically and removed all unnecessary UI clutter and got rid of the embedded bits.

Because I think, Quality is not measured in Quantity.

I’m not implying in any way that my writing is quality work, it’s just a bit cleaner presented that’s all.

Offloading comments to a third party, namely disqus, is the initial step I'll take for migrating my current blog to a static alternative called Jekyll. But more on my decision in a later post. Let's focus on the steps necessary to get those comments up to disqus.

Warning: Because after the migration the comments are getting injected into the page via Javascript, Google and the rest of the Search-Engine-Mafia won't be able index them which basically means users won't be able to search for comments in your post when using a search engine.

Disclaimer: Actually all the tools and most steps used in this post are from Migrating Existing BlogEngine.Net Comments to Disqus, however I ran into some issues while following the guide.

Now to the migration part, first of all we'll need to extract the existing comments from your blog. For doing so we'll use the CommentExporter BlogEngine Extension by @prabirshrestha. Download and extract the extension, and upload the files inside the www directory into the according BlogEngine folders on your webserver. Then log into your blog and head over to the extensions tab of the administration dashboard. Make sure that the extension is enabled and then click the edit link next to. In this new window select the option Intense Debate from the dropdown menu and continue by pressing Export Comments.

Once you have the file on your desktop open it with you favorite text-editor and check that there is no HTML encoded user name inside the tags. If they're encoded I strongly suggest rewrite them into their UTF-8 equivalent, otherwise they're getting messed up by disqus.

Now go ahead and create a disqus account for your blog if you haven't already.

Let's import. Log into your disqus account and select the blog you want the comments to appear on. Then head over to the Tools tab and select Import / Export on the left hand side. Select IntenseDebate as the format then choose the file and hit Import. Depending on the number of comments you have it might take disqus a while to import all of them.

Next up we need to make a minor modification to the BlogEngine source. Open up your FTP browser, select the file post.aspx in the root of your BlogEngine installation and open it. In there remove the following line

var disqus_url = '...';

and add the line

var disqus_shortname = 'fill in your disqus domain username';

The reason for this change is the following: Because we've extracted and uploaded the comments with the pretty url the built in disqus commenting will look for comments matching the ugly but unique guid url, which leads to none of the comments are ever showing up. Of course modifying the export extension, using regex in the text-editor or uploading a URL map to disqus will lead to similar results.

Finally you're able to change the moderating system inside the comments tab of the BlogEngine administration dashboard to Moderated by Disqus. Now don't forget the fill in the Disqus Website Short Name and then upgrade your blog by saving the changes.

One last thing to note, if you're enabling comments for pages and you want the pretty urls for them too you'll need to apply the same modifications for page.aspx as we did with post.aspx.

Wie bereits letztes Jahr ruf foursquare wiederum gestern alle Checker und Checkerinnen auf, sich für einmal wirklich dort aufzuhalten wo eingecheckt wird.
(Ja, ich meine die Super Swarm Badgejäger vom K2)

foursquare? Feiertag? #wtf - dann schau dir mal diese Seite an, danach diese und schliesslich diese.

Tweete - und sie kommen #HowCoolIsThat - Nicht nur aus Zürich (@bindermichi, @pigoni, @mettlerd, @zurcherart, @auge2u) reisten sie an, sondern @cydoniashop aus Graubünden und @timbo_SF, @hoomygumb mit Diana aus unserem nördlichen Nachbarland, Deutschland.
Das Wetter war eher Nerd-Untauglich, wie mir mein roter Nacken zu verstehen gab, was uns allerdings einen schönen Nachmittag auf der Terrasse der Café Des Amis ermöglichte.

Neben den obligaten Gesprächen über Badges, Follower etc. ging's gestern auch um Edellakritze aus Dänemark, Medizinische Maschinen, Künstlernamen, Rechtslagen rund um die IT und nicht zuletzt um den Kampf zwischen Python und Ruby. (aka. Whitespace vs. Code)

Alles in allem ein wundervoller Tag, den ich nächstes Jahr, oder allenfalls auch früher schon, gerne wiederholen möchte. Vielleicht klappt's dann auch mit der Reservationskarte.

Danke für's kommen.

At the last #webtuesday, Steve and I had the opportunity to talk about the 2 day Hackathon we held during the christmas break. (slides below)

If you want to make a hackday yourself be warned that:

• Setting up your environment (developer and production server) will take you much longer that you expect at the beginning. (took as about half a day)
• Keep in mind that working with new technology (especially if you're doing a hackday to learn something new) might be very cumbersome at the beginning. 
• Apart from the lack of knowledge you might have, there can be some delays trying to implement third party libraries (which might contain bugs themselves)
• To keep the team (or just yourself) focused we found it very useful to have a fixed deadline. Sometimes accountability might already be sufficient.
• Before you make your newly developed service public make sure you already have a hosting solution that allows you to scale if demand suddenly increases, furthermore be knowledgeable about where your data gets stored and who can access it. (remove all those "password" passwords at least)

At the end of the talk I demoed a short script to save tweets to a mongoDB database (you'll find the according source on github).

From one day to the other my pinned favorites in the explorer jump list were gone, and with it my workflow.

In order to fix the mess, open up explorer, insert the path below and press enter.

%APPDATA%\Microsoft\Windows\Recent\AutomaticDestinations

As a next step delete all the files inside this folder. Restart your computer. The jump list will now empty but it should work again.

Das Titelbild ist von wwarby und steht unter CC-BY 2.0.

Google’s Irrfahrt
Es werden zu diesem Zeitpunkt wohl alle Wissen, dass Google das Wave Projekt offiziell für beendet erklärt hat. An dieser Stelle lässt sich streiten ob wirklich die vermeintlich wenigen Nutzer, oder ein Entscheider in der Chefetage dem innovativen Produkt den Todesstoß verpasste.
Ähnlich verwirrt agiert Google mit ihrem Hosting Angebot, der AppEngine. Die Sprachen Python und Java sind vielen Programmierern ein Begriff, zudem ist die angebotene Datenbank auf BigTable aufgebaut und somit schnell und gut skalierbar. Zu guter letzt wird das Paket AppEngine mit vielen APIs ausgestattet die dem Entwickler wiederum mögliche Sorgen abnehmen können. Klingt nach einem Programmierer Traum, oder?

Gratis was will man mehr?
Um Unternehmen dazu zu bewegen ihre Software auf die Google Cloud Plattform zu migrieren, wird zusätzlich eine gratis Quota angeboten. Bei Projekten mit geringer Nutzung und Anforderungen können daher durchaus Seiten mit finanziellem Nutzen entstehen ohne, dass dafür selbst monetäre Ressourcen benötigt werden.

Der Teufel steckt im Detail
Die Limitierungen der Plattform treten teilweise erst während der Entwicklung ans Tageslicht. Beispielsweise ist die Datenbank durchaus performant, erlaubt allerdings nicht mehr als 1000 Einträge pro Entity (quasi Tabelle bei einer sonst üblichen relationalen Datenbank) zu speichern und stellt sich somit für viele Projekte als untauglich heraus. Ein weiterer Punkt ist die 30 Sekunden Regel, die eine Seite vom Server bekommt, bis der den jeweiligen Prozess stoppt. Für etwas aufwendigere Datenverarbeitung oder laden einer externen Ressource lässt sich AppEngine somit auch nicht wirklich einsetzen.

Was jetzt?
An dieser Stelle frage ich mich, sollen wir uns neben der Lösung des eigentlichen Problems (des Programmierens) zusätzlich den Kopf zerbrechen wie die jeweilige Logik an die komplett verschiedene Umgebung angepasst werden kann, und uns womöglich sogar einem massiven Vendor-Lock-In unterwerfen oder von Beginn an auf eigens konfigurierte virtuelle Server setzen?

Habt ihr auch schon Erfahrungen mit AppEngine oder ähnlichen Anbietern gemacht? Auf welches Pferd habt ihr schlussendlich gesetzt?

Der failwhale, das Twitter Maskottchen welches jeweils bei Problemen mit dem Dienst auftaucht, entstand für das #twittboat innerhalb von 4 Tagen mit viel Zeitung, Kleister und der Hilfe meiner Mutter (habe 2 linke Hände ;)

Skeptisch ob der Hut nicht doch etwas zu geeky ist, erschien ich mit dem Wal im eigens angefertigten Twitterbag auf der Rudolf-Brun Brücke. Glücklicherweise freuten sich die Twittboater aber über das Maskottchen, was auf etlichen Bildern des #twittboat zu sehen ist.

Um den failwhale Hype positiv zu nutzen wurde dieser, wie im Beitrag #twittboat 2010 erwähnt, auf Ebay versteigert um damit Gutes zu tun. Dank zahlreichen Helferinnen und Helfern kletterte der Preis innerhalb einiger Tage auf 51 Franken die nun der Gruppe swisstweets auf Kiva zugute kommen.

An dieser Stelle ein grosses Dankeschön an die Gewinnerin der Wal-Auktion @monah (Blog). Ebenfalls danke den zahlreichen Mitbieterinnen und Mitbietern, sowie den Helfern die, die failwhale Tweets aktiv Retweetet haben.

Unten: Das neue Zuhause des #failwhale bei @brack_ch – Bild von @monah zur Verfügung gestellt.

Es ist durch Studien erwiesen dass Menschen mit weniger Auswahl durchweg zufriedener sind. Anstatt sich zwischen 100 Zahnpasta Sorten zu entscheiden greift der Grossteil der Konsumenten zu dem im TV beworbenen Markenprodukt oder der Sorte die schon seit Ewigkeiten verwendet wird. Der Grund für diese Käufer Reaktion unterliegt dem Gedanken, dass sich Menschen nicht gerne Entscheiden und falls sie dies doch tun müssen, sie am glücklichsten sind bei möglichst wenigen Optionen.

“keep it simple”
Ich denke in diesem Gebiet hat Apple wissentlich oder per Zufall den richtigen Weg gefunden. So muss beispielsweise bei einer Neuanschaffung eines Macbook lediglich zwischen 3 Grössen entschieden werden. Nach dem Klick auf Kaufen und dem Start des Bestellvorgangs werden erst die verschiedensten weiteren Konfigurationsoptionen angezeigt wobei wiederum nur zwischen einigen wenigen entschieden werden kann. So ist es Apple möglich eine gewaltige Palette von Optionen abzudecken ohne dass sich der geneigte Käufer bereits im Vorfeld zwischen 20 unterschiedlichen Varianten zu entscheiden hat.

Die Schattenseite der Entscheidungsfreiheit
Ich tue mich schwer, es zu sagen, aber das negativ Beispiel par excellence ist in diesem Fall die Firma Microsoft mit den unendlich differenzierten Windows und Office Versionen bei denen sich der Kunde bereits beim Kauf im klaren sein muss was im Laufe der Nutzung alles gebraucht wird. Einfach nur #epic #fail.

Alles in allem, Entscheidungen werden nie leichter, der Fragende kann aber alles daran setzten damit sie uns leichter erscheinen.

Das folgende TED Video zeigt eine Präsentation von Barry Schwartz der genau diesen Entscheidungsüberfluss thematisiert.

Als am #twuplu auskam, dass das GA von @bireweich auslaufen würde, zögerten wir nicht lange und machten uns am

1. Juli auf den Weg quer durch die Schweiz (#qdds). Das Ziel war nicht möglichst weit zu fahren, sondern möglichst viele Twitterer und Blogger spontan auf dem Weg zu treffen.

So trafen wir uns um 7.45 in Thalwil und setzten den ersten Tweet in die Welt:

Da uns gerade niemand Antwortete begaben wir uns nach Zürich in den Apple Store, was btw. mein erster Besuch in der Höhle des Löwen war. Nachdem wir alle möglichen Gerätschaften ausprobierten bewegten wir uns Richtung Hauptbahnhof weiter, lustigerweise dauerte es nicht lange bis sich das #qdds Team im Dataquest befand mit einem iPad in der Hand am twittern.

Um 11.12 fand dann der langersehnte erste Kontakt mit einem anderen Twitterer statt und nicht einfach irgendjemandem sondern es war @AbtMartin vom Kloster Einsiedeln höchstpersönlich. Während der Zugfahrt wurde über Twitter und die damit verbundenen Möglichkeiten diskutiert. Wie beispielsweise Monitoring betrieben werden kann und was für Werkzeuge es dafür gibt. Punkt 12 Uhr lieferten wir in vor dem Kloster ab und begaben uns völlig planlos zum nächsten Zug.

Ab Einsiedeln fuhren wir über Wädenswil - Pfäffikon nach Rapperswil mit der Hoffnung auf ein Nest von möglichen Twitterern zu treffen. Da sich niemand meldete beschlossen @bireweich und ich über den Steg wiederum nach Pfäffikon zu gehen und danach Richtung Zürich zu Reisen.

Auf dem Weg von Pfäffikon nach Zürich verliessen uns zudem unsere digitalen Helfer, womit kein Kontakt mehr mit Twitterern hergestellt werden konnte. Aus der Not gingen wir an die ETH um uns und den Akkus etwas Stärkung zu gönnen.

Aufgrund der fortgeschrittenen Zeit brach @bireweich um 17 Uhr bereits wieder nach Luzern auf, sodass ich den 2. und letzten Twitter Besuch am #qdds alleine durchführte. Weil ich mich als Digital Native generell sträube Fahrpläne zu lesen oder überhaupt eine Reise im Vorfeld zu planen, liess ich mich vom Bahnhof Altstetten per Google Maps an den Firmensitz der Kublé AG lotsen. War wahrscheinlich sehr amüsant mir beim navigieren zuzuschauen ;-). Dort angekommen gabs kühle Getränke und tolle Gespräche mit @gustavosalami, @christophhess und dem restlichen Team über mögliche Chancen in der Schweizer Software Branche.

Alles in allem war es ein schöner Tag. Nachträglich kann man sagen, dass wenn wir den Tag etwas länger im Vorraus geplant hätten, uns wahrscheinlich einige Twitterer mehr über den Weg gelaufen wären.

Mehr Bilder sind auf flickr zu finden

Schön war es das #twittboat, da werden mir wohl alle zupflichten. Dies war neben den herausragenden Leistungen der Paddlerinnen und Paddlern auch den Sponsoren daydeal.ch, sib.ch, nine.ch, amboss bier, kochen mit shibby, Rahel’s sweet temptations, carpathia, frühjahr und der grossartigen Organisation von @dhaitzch zu verdanken.

Mit dem #twittboat haben wir der Welt gezeigt, dass Twitterer nicht (nur) Nerds sind die sich Tag ein Tag aus im Keller aufhalten und die Sonne nur vom hörensagen kennen.
Ich möchte sogar noch einmal einen Schritt weitergehen und der Welt beweisen, dass wir uns auch für soziale Projekte abseits des Internets einsetzen. Daher wird das Maskottchen (der failwhale)welches uns jeweils auf den Rennen begleitete auf Ebay versteigert und der Gewinn der Gruppe swisstweets auf Kiva überwiesen. 
Die failwhale Auktion dauert 10 Tage, also nichts wie los und mitsteigern.

Nachdem ich schon einiges von Tina Roth Eisenberg aka. swissmiss und den creativemornings gehört habe, war es nun an der Zeit selbst an einem teilzunehmen zumal es gerade vor der Haustür stattfindet.

Der Gastgeber Rolf Hiltl, stellte den ca. 200 Teilnehmern seine Firma Hiltl und Tibits vor und erklärte warum auf der Speisekarte auch nach ca. 120 Jahren noch immer nur Gemüse steht, obwohl sich Gäste teilweise über das fehlende Fleisch beklagten.

Wie von Tina bemerkt wurde gibt sich Hiltl für eine schweizer Firma generell enorm innovativ. Ich denke sie hat da nicht ganz unrecht, so wird man nicht in jedem Restaurant eine Twitterwall vorfinden #ilike. Ob bald anstatt mit einer Karte aus Papier per iPad bestellt werden kann, liess Rolf Hiltl dagegen offen.

Weitere Bilder vom Event findet man hier oder in der creativemorning Gruppe auf flickr.

Schon seit einer Weile wird in Szene-Blogs immer wieder von der neuen “Wave 4” der Windows Live Essentials geschrieben, dabei handelt es sich um neue, verbesserte Versionen der Photo, Video, Chat, Blog und Synchronsations Software die gratis erhältlich sind.

Aufgrund der bevorstehenden finalen Version, möchte ich an dieser Stelle kurz die Vor- und Nachteile von Live Sync aufzeigen, und insbesondere mit der möglichen Konkurrenz (Dropbox und Wuala) vergleichen. Es ist mir dabei klar, dass die Zielgruppen und Aufgabengebiete der hier verwendeten Konkurrenz-Anbieter nicht zwingend den selben wie Live Sync entsprechen.

Kein Live Sync auf Linux
Anders als Wuala, wo auf Java gesetzt wird und Dropbox die einen nativen Client haben, funktioniert Live Sync nicht auf Linux obwohl es dank dem Mono Projekt teilweise möglich wäre .NET Applikationen unter Linux zu betreiben.

Kein Cloud-Backup von versteckten Dateien
Gerade beim programmieren schätze ich Synchronisationsdienste unheimlich, so füge ich den Code erst dann zum Subversion Archiv hinzu wenn ein Feature fertig programmiert und nicht schon früher wegen dem Wechsel des Arbeitsgerätes. 
Wie bei Wuala ist es auch mit Live Sync leider nicht möglich versteckte Dateien über die Cloud zu synchronisieren, der Konkurrent Dropbox erlaubt dies jedoch. Sollen auch mit Live Sync versteckte Ordner wie Subversion Verzeichnisse auf andere Rechner übertragen geht dies nur über eine direkte P2P Verbindung und ohne Cloud Backup.

Synchronisation von Programm Einstellungen
Früher war deli.cio.us das Mass aller Dinge wenn es um Lesezeichen ging, egal an welchem Computer man sass die Favouriten sind immer übers Netz erreichbar. Als Chrome Beta Nutzer konnte ich einige Zeit später die Bookmarks sogar im Programm selbst synchronisieren und sparte mir somit das immer wiederkehrende Anmelden bei deli.cio.us. Endlich ist nun auch die Lesezeichen Synchronisierung beim Internet Explorer angekommen, man kann mir allerdings nicht vorwerfen dass ich daher wieder auf IE wechseln würde, dafür muss klar mehr getan werden.
Das mit der Bookmark synchronisierung geht noch etwas weiter und zwar hat Microsoft mit Live Sync einen Weg geschaffen wie auch andere Programme ihre Einstellungen über mehrere Computer hinweg einheitlich führen können, so könnte ein Administrator der Firma XY in der Konfigurationsdatei einer x-beliebigen Firmen Applikation eine Änderung machen und fast instantan wird dies auf den Rechnern der Angestellten angewandt. Mit Dropbox wäre dies ebenfalls möglich, falls die Konfigurationsdateien in den Ordner ‘My Dropbox’ verschoben werden können.

Sync-Ordner sind frei wählbar
Jedem Dropbox Nutzer ist bekannt, dass nur Dateien im Ordner ‘My Dropbox’ resp. dem Ordner der bei der Installation angegeben wird, synchronisiert werden. Das Team arbeitet allerdings schon seit einiger Zeit an einer Lösung bei dem auch x-beliebige Ordner miteinander abgeglichen werden können. Live Sync auf der anderen Seite kann dies schon jetzt. Beliebige Ordner sind entweder mit der Cloud und anderen Rechnern oder einfach nur mit bis zu 30 anderen Computern synchronisierbar.

Remote Desktop
Als weiteres Killer Feature bekommt Live Sync den aus Mesh bekannten Remote Desktop. Dies ist vorallem praktisch um dem Kunden übers Internet den Computer zu reparieren oder einfach Geeklike aus dem Büro den Heimrechner zu steuern.

Fazit
Microsoft hat sicherlich hie und da noch etliche Schachstellen auszubügeln um im Markt gegen innovative Produkte wie Dropbox und Wuala bestehen zu können. Ein weiteres absolutes Killer Feature wäre beispielsweise, dass per Live Sync in die Cloud hochgeladene Dokumente auch mit den Office Web Apps per Browser editiert werden könnten, womit die ganze Nutzungs-Bandbreite unterstützt würde.
Man darf allerdings nicht vergessen, dass Live Sync momentan noch im Beta Status ist und hoffentlich auf die finale Version hin noch um einiges Attraktiver wird, ob es der Beginn des Synchronisations-Nirvana ist, diese Entscheidung überlasse ich dabei gerne euch.

Beim Mobile City Walk Zürich (flickr Gruppe) von Gestern war eine der Anforderungen, dass die Bilder mit GPS Daten versehen, hochgeladen werden. GPS Tagging mag bei anderen Smartphones Standard sein, leider nicht so bei meinem Modell dem HTC HD2, was auf Windows Mobile 6.5 basiert.

Um dennoch die Bilder mit GPS Informationen in den EXIF Daten zu versehen muss eine kleine Registry Änderung auf dem Smartphone vollzogen werden. Dafür wird CERegEdit gebraucht, was nicht Open Source, jedoch gratis erhältlich ist.
Nach dem herunterladen und installieren von CERegEdit, wird das Smartphone per ActiveSync mit dem Computer verbunden und CERegEdit gestartet. Auf Windows Vista oder Windows 7 sollte CERegEdit unbedingt mit Administrator Rechten gestartet werden, da die Applikation ansonsten nicht richtig funktioniert.

Anschliessend nun die Schritte um GPS Tagging für Bilder zu aktivieren.

1. Wähle in CERegEdit links oben Connection und anschliessend Connect, was die Registry vom Gerät lädt.
2. Suche in den Ordnern in der linken Spalte nach dem Ordner HKEYLOCALMACHINE > Software > HTC > Camera > P10.
3. Markiere den Ordner P10 in der rechten Spalte und doppelklicke auf Enable in der rechten Spalte.
4. Setze nun den Wert von Value data von 0 auf 1 und bestätige mit OK.
5. Schliesse die Applikation und kappe die Verbindung mit dem Computer.
6. Öffne die Kamera App auf dem Smartphone, tippe rechts unten auf auf Einstellungen und nachher auf die Kamera resp. die Aufnahmemodus Auswahl. Hier kann nun der Modus GPS-Foto gewählt werden. Die GPS Bilder befindet sich übrigens nicht im selben Ordner wie die anderen, nicht GPS getaggten, sondern auf den Speicherkarte unter My Documents > My POI.

Am 7. Juni 2010, traute ich mich als nicht Apple-Gerät-Besitzer nach Bern an das #wwdcbe Tweetup wo die WWDC Keynote von Steve Jobs per Liveticker verfolgt wurde. Anstatt die Demos von Steve als Video zu schauen, besprachen wir die Features untereinander oder checkten die Twitter Timeline. Am Ende des Abends wussten wir, sofern ich es jetzt sagen kann, über alles Bescheid obwohl nur kurze Meldungen und Bilder zu uns durchsickerten.

Ist der Fakt, dass Apple keinen Livestream anbietet eine Kosten Frage oder allenfalls eine geschickte Marketingstrategie?

Bisher hatten die Apple Konkurrenten sprich Google und Microsoft jeweils ihre Keynotes Live an jeweils 10'000 bis 20'000 Zuschauer gestreamt. Da sich bei einem Streaming die Bandbreiten für jeden Nutzer addieren, muss bei 20'000 Zuschauern mit ca. 1.5 Mbit/s eine Bandbreite von 30'000 Mbit/s also 30 Gbit/s bereit stehen. Da Apple ebenfalls verschiedenste Kinotrailer hostet, sollte die Bandbreite die gebraucht wird und die daraus resultierenden Kosten nicht wirklich entscheidend sein.
Auf der anderen Seite kann "kein Livestreaming" viele positive Effekte haben. Erstens sind die Sitze in dem Saal viel begeehrter, da die anderen Ausserhalb warten müssen bis das Keynote Video online ist. Zudem ist Twitter, und sind andere Quellen, voll von Neuigkeiten, vornehmlich in indexierbarem Text, was die Werbewirkung noch einmal maximieren kann.

Meine Frage nun, würde diese Taktik auch bei anderen Firmen und Events funktionieren?

Warum bieten beispielsweise Microsoft oder Google einen Livestream an, wäre doch günstiger und besser wenn nicht?
Die einzige Erklärung auf diese Frage beruht bisher darin, dass Google ihre Youtube Plattform und Microsoft ihren Silverlight Streaming Service promoten möchten und es sich daher nicht leisten können keinen Livestream anzubieten.

Was sind eure Meinungen zu diesem Thema? Pro oder Kontra Livestream?

Im Januar 2010 habe ich hier auf diesem Blog eine Möglichkeit vorgestellt wie mithilfe einer Batchdatei und des Open Source Programms WGET die eigenen Webseiten offline gesichert werden können. Website mit WGET und einer Batch Datei sichern

Bei vielen verschiedenen Webseiten kann der Sicherungsvorgang leider ganz schön viel Zeit beanspruchen da WGET und das Batch Skript lediglich seriell ausgeführt werden. Es gibt allerdings eine Möglichkeit wie das Backup quasi parallel ausgeführt wird. Als Ausgangspunkt brauchen wir das schon erstellte Backup Skript vom Januar 2010 (backup_skript), welches ungefähr so aussieht:

{% highlight text %} "C:\wget ordner\wget.exe" -P"C:\website sicherung 1" ftp://admin1:passwort1@ftp.example1.com/ –m

"C:\wget ordner\wget.exe"" -P"C:\website sicherung 2" ftp://admin2:passwort2@ftp.example2.com/ –m {% endhighlight %}

Im Ordner, in welcher sich diese Datei befindet, erstellen wir nun einen Unterordner, in meinem Falle websitebackup. In dem Ordner websitebackup wird für jede einzelne Website eine eigene Batch Datei erstellt, bsp.: example1.bat. In example1.bat kommen nun die Anweisungen, welche nur diese eine Seite betreffen, in unserem Beispiel also:

{% highlight text %} "C:\wget ordner\wget.exe" -P"C:\website sicherung 1" ftp://admin1:passwort1@ftp.example1.com/ –m {% endhighlight %}

Diese Schritte werden wiederholt bis alle Anweisungen im Skript backup_skript in einzelnen Batch Dateien im Ordner website_backup vorhanden sind.

Zum Schluss öffnet man die Datei backupskript mit einem Editor und es wird pro Batch Datei im Ordner websitebackup eine Linie eingefügt.

{% highlight text %} START website_backup\example1.bat START website_backup\example2.bat etc. {% endhighlight %}

Falls nun das Skript backup_skript aufgerufen wird, öffnen sich viele verschiedene Fenster gleichzeitig, wodurch der Backupprozess eine gewisse Parallelität gewinnnt.

Da ich es leid bin dauernd den ganzen Regenwald an die Vorlesungen mitzuschleppen stellte ich auf Digital um. Es ist nämlich möglich mit Word und einigen Shortcuts den Text, den der Professor an die Tafel schreibt, recht fliessend abzutippen. Die Tastenkürzel sind dabei in MathML, einer an LaTeX angelehnten Sprache verfasst.

Dank Thomas Co, von der Michigan Technological University und seiner handlichen Zusammenfasssung sollte dabei die MathML ausdrucksweise rasch erlernbar sein.

Beim Zugriff auf Google Mail per IMAP lädt der Client (Thunderbird, Outlook, etc.) auch die SPAM E-Mails herunter, sodass Benutzer diese ebenfalls zu Gesicht bekommen. Falls allerdings, aus Tradition, auf POP gesetzt wird um E-Mails vom Server zu holen, gehen SPAM verdächtige E-Mails eventuell am Nutzer vorbei. Hinzu kommt, dass Google SPAM nach ca. 60 Tagen automatisch löscht.

Erstelle einen neuen Filter und fülle dabei im Feld Mit diesen Wörtern den Begriff is:spam ein. Klicke anschliessend auf Nächster Schritt.

Da foursquare eine relativ stabile statische API besitzt, (anders als Gowalla) erstellten Entwickler, schon seit geraumer Zeit, Services die den täglichen 4sq-Nutzer untersützen.

• Nebenbei verrät bethemayor.com, das zum Mayor nur ein Check-In pro Tag gezählt wird. Geht wohl daher mehr um Ausdauerals um fleissiges Treiben. #nicetoknow

Gestern am 20. Mai wurde das wahrscheinlich erste Tweetup auf Argauer Boden durchgeführt, das #tweetupaarau. Die Location wahr angenehm nahe am Bahnhof und konnte auch sonst überzeugen.

Gestern an der Google I/O, der alljährlichen Entwicklerkonferenz des Suchmaschinenriesen, wurde bekanntgegeben, dass nun auch Chrome einen Web Store bekommt aka. Goldesel für IT Firmen. Das Konzept an sich ist sicher nicht neu, da Apple schon seit einigen Jahren einen solchen für das iPhone und nun auch deren Tablet betreibt, und genau da wird es spannend. Google hat mit dem Chrome eine relativ einfache Umgebung geschaffen in der mit HTML (neu HTML5) etwas CSS und Javascript voll funktionsfähige Applikationen erstellt werden können die danach gewinnbringend an den Nutzer weiterverkauft werden.

Meine Vermutung geht nun dahingehend, dass diese Web Store Applikationen nachher out-of-the-box auf einem Tablet mit ChromeOS laufen. Für Entwickler denen das nicht genug ist, kommt vielleicht sogar noch Java Support hinzu, was im Endeffekt das Google Tablet zu einer ernsthaften Konkurrenz für das Apple iPad machen könnte.

Es ist mir klar, dass die Prognose aktuell viele unbekannte Variabeln enthält, doch bin ich interessiert was ihr zu diesem Thema denkt. Hat Google das Potential, Apple aus dem Mobil Geräte Markt zu verdrängen?

Normalerweise schreibt man etwas Code auf dem eigenen Rechner, testet diesen und fügt ihn zum Subversion Verzeichnis hinzu, danach wird die aktuelle Version exportiert und per Filezilla auf den eigenen Server hochgelden. Dies macht Sinn, da somit fixe Versionen vorhanden sind auf die allfällig wieder zurück gewechselt werden könnte.

Schön und gut, doch was wenn die Applikation schon während dem programmieren laufend auf dem Server getestet werden will? Lädt man dann die ganzen SVN Verzeichnisse auch hoch? Oder jeweils einfach Datei um Datei, sodass die Subversion Daten nur auf dem eigenen Rechner bleiben.

Es gibt eine viel einfachere Lösung. Zuerst wird View im Menu ausgewählt und danach auf Filename filters geklickt. Alternativ geht auch der Tastatur Shortcut Ctrl + I. Im neu erscheindenen Fenster aktiviert man das Häckchen bei CVS and SVN directories und schon werden die Subversion Verzeichnisse von Filezilla ignoriert.

Nun ist es möglich einen Ordner, welcher ein SVN Verzeichnis beinhaltet auf den Webserver zu laden ohne dass dabei die Subversion Dateien ebenfalls übertragen werden.

Am 21. April stellte Microsoft auf der facebook f8 Konferenz eine Beta Version ihrer Office Web Apps vor. Die Online Version der bekannten Office Suite beinhaltet bis dato die gebräuchlichsten Office Anwendungen wie Word, Excel und Powerpoint.

Die Schwächen von Office Web Apps (OWA) sind momentan die stärken von Google Docs (GD), so blockiert beispielsweise OWA bei jedem speichern das Fenster wie man dies schon von Office Workspace her kennt, GD hat mit der Übernahme von Etherpad (danke an @giu, @LiFrT und @dangraf) auf der anderen Seite eine Speichertechnik welche sehr schnell ist und das weiterschreiben erlaubt. Ebenso habe ich persönlich Mühe mit der Fullscreen Darstellung von OWA, so passen ganze Absätze auf eine Linie (24”). GD hat dieses Problem erkannt und ihre Version bedeutend schreib- und lesefreundlicher gestaltet.

Stärken von OWA gegenüber GD sehe ich in der grossen Verbreitung der Offline Version von Office. So können Nutzer ihre Daten kostenlos auf Skydrive ablegen, diese bei Bedarf mit OWA abändern und sind dabei niemals gezwungen sich in ein neues Programm einzuarbeiten weil überall die bekannte Ribbon Oberfläche zu sehen ist. Ebenso ist es möglich die neuesten Office Effekte sowohl off- wie online zu verwenden, somit ist der Nutzer nicht wie bei GD gezwungen die jeweiligen interaktiven Elemente in statische Bilder umzuwandeln. Zusätzlich hat Microsoft durch die Integration in Facebook eine gute Basis um eine solide Kundenbindung zu erreichen.

Mein Fazit — Trotz der teilweise schlechten Unterstützung und dem derzeit abgeschalteten Offline Modus ist mein Favorit durchaus Google Docs. Dies aus dem Grund, dass Google Docs deutlich schneller ist und mir Docs.com den Anschein macht ledigleich ein erweitertes TinyMCE zu sein, welches durch zu viel Javascript an Performance einbüsst. 

Sowohl das von mir getestete Google Docs wie auch Docs.com sind aktuell nicht in einer “Business Ready” Phase, daher können sich bei beiden noch die einen oder anderen Dinge verbessern. Dürfen daher noch bei beiden auf Einsicht hoffen...

Update vom 8. Juni 2010 — Office Web Apps sind ab jetzt ebenfalls auf office.live.com verfügbar. Mit Office 2010 können die Dateien nun direkt dort gespeichert und freigegeben werden. Genauere Details kann man durch den offiziellen Blog Beitrag oder durch durchs selber ausprobieren erhalten.

Nun ist die Zeit gekommen und mein Blog verabschiedet sich von seinem orangen Kleid (pubertäre Phase) und zieht ein blaues professioneller wirkendes Gewand an.

Für das CSS benutzte ich das BlogEngine.NET Standard Stylesheet und erweiterte es mit einigen CSS3 Elementen wie text-shadow, box-shadow und rounded-border. Ebenso wird ab diesem Moment der Facebook Like Button und Tweetmeme Retweet eingeführt. Bin gespannt ob es allenfalls mehr Konversationen hervorbringt.

Das HTML resp. XHTML erfuhr wenige Änderungen und ist, sofern keine Flash Videos oder Widgets von Drittanbietern eingebunden werden, völlig W3C konform.

That’s it. Wie gefällt es euch? Evtentuell Anregungen für eine weitere Interationen?

Heute am 16.4 feiert foursquare, der beste Location Dienst ;-), seinen eigenen Feiertag, den foursquareDay. Der Tag ist keineswegs zufällig gewählt, sondern unterliegt rein mathematischen Gesetzmässigkeiten. So heisst 4 auf Englisch four und four-squared daher 4 im Quadrat was nichts anderes als 16 ist.

Leider gibt es in der Schweiz keinen Ort wo man auch mitfeiern kann, vielleicht ja nächstes Jahr. Als Ersatz präsentiere ich euch heute die erste Episode der Foursquare Cops.

Falls ihr noch nicht genug foursquare habt gibt es hier noch mein widget für blogengine.

Bei meinem in der Schweiz erstandenen HTC HD2 war standardmässig die folgende Email Signatur eingestellt: Gesendet von meinem HTC.
Die Signatur an sich ist nicht wirklich schlimm, doch sobald man Services wie flickr, posterous und eat.ly benutzt welche Emails parsen, hat man die Email-Signatur plötzlich auf allen Bildern resp. Beiträgen in der Beschreibung. Natürlich könnte man den Spruch auch einfach jedesmal von Hand löschen, doch warum kompliziert wenn es auch einfach geht.

Um die Signatur zu deaktivieren resp. ändern tippe auf Start und nachher auf das Menu E-Mail. Wähle nun Menu (rechts unten) an.

Tippe auf Optionen um ins nächste Fenster zu gelangen. Dort kann nun das Konto ausgewählt werden für welches die Signatur geändert werden soll. Nach der Auswahl einfach auf Signaturen tippen und es ist schon fast geschafft.

Im letzten Schritt hat man die Möglichkeit die Signatur ganz zu deaktivieren oder einfach eine eigene zu definieren. (Auswahl nach belieben) Nach einmal tippen auf OK ist die nervige Standard Signatur verschwunden.

Nebenbei die Screenshots dieses Post wurden mit der Software Ilium Software Screen Capture gemacht die gratis heruntergeladen werden kann. (Leider nicht OSS...)

Hi users of blogengine. I'd like to announce another minor update to the foursquare widget for your favourite blogging platform which can be downloaded from codeplex. By the way this will be the last release working with the feeds, the next release will be running with the foursquare API.

out-of-the-box usage
Now everyone is able to use the plugin with your out-of-the-box BE installation, because I've changed the parts which were using LINQ to use .NET 2.0 methods. So there's no need to change the framework version to 3.5 anymore...

W3C compliant
The other thing I'd like to announce is that the widget is now fully W3C compliant, like BE itself.

Icons are back
Last I want to mention that the icons are getting embedded again, because they disappeared in some browsers while displayed via css.

Important
You probably have to reset the blogengine application after you've uploaded the widget to your hosting provider. Sorry for that.

Am letzten Freitag habe ich die Vorlesungen für einmal ausfallen lassen und mich auf Genf zum internationalen Autosalon begeben. Ist ja auch nicht jeden Tag…

Neben all den schnellen Rennboliden lag der Trend dieses Jahr in umweltschonenden, ökologischen Autos, so präsentiere zu meinem verwundern sogar Ferrari ein hybrides Auto.

Das hybride Auto mag gut sein, doch ich denke für Frau und Herr Schweizer wäre eine andere Lösung noch effizienter, z.B. die Autos welche ganz auf Strom als Antriebskraft setzen, wie dies die Firma Protoscar vorstellte. Okay, das Auto an sich könnte etwas vorteilhafter aussehen, doch sind es nicht die inneren Werte die zählen ;-)

Die technischen Daten des Lampo2 verheissen nämlich ein maximales Drehmoment von 640Nm welches das 1.5 Tonnen Elektro-Auto in ca. 5 Sekunden von 0 auf 100km/h beschleunigen kann. Der einizige Minuspunkt sehe in der geringen Reichweite von 200km, danach müssen die Akkus wieder geladen werden, dies dürfte aber bei unserem dichten Tankstellennetz kein Problem darstellen.

Neben der Entwicklung des Prototypen beschäftigte sich Protoscar ebenfalls mit der Lade-Frage. So konnten mithilfe von Partnern, 3 verschiedene Ladetechniken, in Form von Strom-Tankstellen, entwickelt werden. Die offensichtlichste und günstigste Variante, das Aufladen über Nacht; daneben sind auch Ladestationen an öffentlichen Parkplätzen vorgesehen. Die schnellste Methode um den Akku wieder zu füllen soll eine 15 Minuten Schnellladung sein, so à la 'drink and drive' (nicht zu verwechseln mit drink or drive)

Bei den aktuellen Strompreisen schlagen dabei, laut Protoscar, 100km Fahrdistanz mit ungefähr 2.40 Franken zu Buche, also im Endeffekt ein vielfaches weniger als was herkömmliche Brennstoffe kosten. Ich nehme jedoch an, sollten eines Tages ein Grossteil der Bevölkerung wirklich auf Elektroautos wie den Lampo2 umsteigen, so müssten die Stromlieferanten ihre Netzinfrastruktur nochmals für die nun grösseren Verbraucher umbauen, was bei der Stromladung eine Preiskorrektur nach oben bedeuten würde.

Ich kann mir vorstellen, das solche Autos besonders für kleinere regional agierende Unternehmen und für Familien interessant sein werden. Bis ich das Kleingeld besitze um mir so ein Gefährt anzuschaffen muss ich wohl noch ein wenig Zug fahren, ist ja sowieso nochmals besser als jedes Elektro-Auto.

Was ist eure Meinung zum Thema Autos mit Elektro-Antrieben? Eine Option bei der nächsten Anschaffung? Was spricht dagegen?

Notice
There's a newer release available.

During the last week I've added Bing Maps to the widget, so that you're last check-ins can be displayed on there.

Can I deactivate the map?
I've assumed that not all of you, would like to show your check-ins on the map aswell, so I've implemented the option to turn the map off.

Will the map play nicely with my current theme?
For everyone with a custom designed theme it sometimes can be frustrating adding another widget because you have to alter design settings everytime a new version comes out, to make this part easier, you can now edit the height and width settings in the edit section of the foursquare blogengine widget.

Where can I find the widget?
The new release, as all the other releases, is available at the according codeplex site.

Important
With the current version you'll still need to reset the application after you've uploaded the widget. Sorry for that.

Heute möchte ich euch das TED Video über Augmented Reality Karten präsentieren (Karten mit erweiterter Realität). Weiss schon, Microsoft, da werden sicher wieder alle Apple und Google Fanatiker wegklicken, allerdings ist das deren Verlust, denn es lohnt sich allemal sich dieses Video zu Gemüte zu führen. Gezeigt wird die neueste Generation von Bing Maps (BM), die nun zumindest in den Städten der USA, einiges zu bieten hat und eventuell eine ernstzunehmende Konkurrenz für Google Maps (GM) werden könnte.

WorldWideTelescope
Implementiert wurden unter anderem altbekannte Dinge wie Streetview, allerdings auch wirklich neue Features wie WordWideTelescope sobald in der Streetview Ansicht in den Himmel geschaut wird.

Lokale Photosynths und Indoor Streetview
Desweiteren sind diejenigen Photosynths, sogenannte 3-dimensionale Fotocollagen ,die mit GEO Daten versehen sind besonders herausgehoben, sodass die Gegend noch besser als mit Streetview erkundet werden kann, somit können auch Innenräume und Büros der Öffentlichkeit zugänglich gemacht werden. An den hochfrequentierten Orten setzte Microsoft teilweise schon Rucksackkameras ein, und das Resultat kann sich durchwegs sehen lassen.

Flickr Bilder präzise in Streetview eingebunden
In der Präsentation werden zudem Interaktionen mit GEO getaggten Flickr Bildern gezeigt, hier sehe ich den Anwendungszweck besonders in der Darstellung der Veränderung eines Ortes. So könnte man sich sicher schneller wieder an Orten zurechtfinden, die man seit Jahrzehnten nicht mehr besucht hat oder aber auch einfach um der Bevölkerung die Geschichte eines Ortes näherzubringen.

Live Video in Karten Material eingebettet
Zuletzt folgt das beste, die Live-Video Integration. Keine Ahnung wie die das Signal immer richtig an den schon vorhandenen BM Bildern ausgerichtet haben, allerdings wäre so was an einem Live Event der Hit, man stelle sich sowas an Olympischen Spielen vor.

Eingeschränkte Nutzung da Silverlight nicht überall installiert ist
Der einzige negativ Punkt sehe ich in der konsequenten Verwendung von Silverlight (SL). Kann mir schon vorstellen das Video Integration mir Javascript (JS) wohl eher eine ungemütliche Angelegenheit wäre, doch schliesst SL bereits wieder einige Internet Benutzer aus. Vielleicht wäre hier eine HTML5 Version denkbar? Die Basis Version von BM ist aber nach wie vor in der HTML mit JS Version verfügbar, halt ohne Glossy Features.

Bis dato gelang es mir leider nicht diese Features selbst zu testen da die Version die präsentiert wurde eine private TP (Technology Preview) war. Da hilft wohl nur warten und Däumchen drehen.

Was meint ihr zu den Augmented Reality Karten? Traut euch, nur zu...

Notice
There's a newer release available.

Last Sunday I decided to build a foursquare sidebar widget for BlogEngine.NET since there wasn't anything around yet. The current version simply shows the last places you've checked-in and is mostly based on the twitter widget from Mads Kristensen.

Requirements
In order to use the widget you will need to have .NET 3.5 installed on your server. I will probably port everything to .NET 2.0 later, but since I was used to work with LINQ, I implemented everything in .NET 3.5.

Installation
First of all download the current version available at codeplex. Extract it and upload everything to your BlogEngine directory into the widgets folder. If you've uploaded the files and switched your current BlogEngine installation to .NET 3.5 you're ready to open your site in the browser and add the widget to the sidebar.
After you've added the widget, you'll have to specify some settings regarding your foursquare feeds. Simply open https://feeds.foursquare.com and copy-paste the urls for the rss and kml feeds into the according input fields inside the foursquare widget edit section. Then go to your foursquare page by clicking on me in the navigation bar at the top, copy and paste the url into the account url input field. Next decide how much your feed should be requested from foursquare. But keep in mind, that if you choose the number of request per hour to high you might get blocked by foursquare. I guess every 15 minutes should already be enough for the average user. Finally choose how many check-ins you want to display on your blog. Next save your settings, and then you're ready to enjoy foursquare together with BlogEngine.NET.

Important
It's possible that the BlogEngine application has to be restarted, after you have added the foursquare widget.

If you have any suggestions or ideas how the widget can be extended or improved please feel free to leave to contact me on twitter.

Im Sommer 2008 gerade nach erfolgreich bestandener Matur war ich zusammen mit einem Freund im Westen Canadas unterwegs. Dabei entstanden einige Panoramas welche nun endlich zusammengesetzt wurden. (ich weiss... könnte schneller gehen ;-)

Diese Panoramas lassen sich exzellent für Dualscreen PC Systeme als Hintergrundbild nutzen. Die maximale Auflösung ist jeweils 3840x1200 Pixel was für zwei 24 Zoll Monitore ausreichen sollte. Damit nicht alle Bilder einzeln heruntergeladen werden müssen, kann man auch das
Windows 7 Themepack herunterladen.

Whistler Blackcomb mit Ilanaaq links

Nanaimo auf Vancouver Island

Kelowna

Drumheller

Maligne Lake

Valley of the five lakes

Valley of the five lakes

See oberhalb von Lake Louise

Lake Minnewanka

Lake Minnewanka

See auf dem Weg von Vancouver auf Banff

See in der nähe von Whistler Bungee

Grouse Mountain bei Vancouver

Insel nahe Tofino auf Vancouver Island

Vancouver Island

Die Zune Software das schöne Pendant zu Apples iTunes ist bei mir die wahrscheinlich am meisten genutzte Applikation neben dem Twitterclient, Outlook und dem Browser.
Damit das Programm schön flüssig läuft und die Vodcasts auch möglichst schnell mit dem Gerät synchronisiert werden können, werden die Videos vorkonvertiert und im Cache gespeichert.

Falls man ohnehin schon knapp an Speicherplatz auf dem C Laufwerk ist dürfte das cachen womöglich eine mittlere Katastrophe auslösen. Damit es nicht so weit kommt kann man den Cache Speicher einschränken was eine Performance einschränkung bedeutet oder man verschiebt den Cache Ordner einfach auf ein anderes Laufwerk. Somit gewinnt man ruckzuck ca. 7GB an Speicherplatz was den Computer unter umständen wieder recht beschleunigen kann.

Wie verschiebt man den Cache der Zune Software?
Nach dem starten der Applikation klickt man rechts oben auf Einstellungen

und danach auf gerät

und nun auf Konvertierungseinstellungen. Unter dem Punkt Konvertierungsort ist es möglich den neuen Speicherort des Caches festzulegen.

Nach dem Klick auf OK werden sämtliche Cache Dateien an den neuen Speicherort verschoben.

Letzte Woche haben wir gesehen wie man den Webspace sichern kann. Dieses mal werden wir uns ums Backup der MySQL Datenbank kümmern. Kurz vorweg, ich werde ich in diesem Beitrag nur über das sichern einer von aussen zugänglichen Datenbank schreiben. Ebenfalls ist das hier gezeigte für Windows Vista / 7 vorgesehen.

Bevor wir mit der eigentlichen Sicherung beginnen können, muss ein Passwort für das aktuelle Benutzerkonto vergeben werden. Um dies zu bewerkstelligen auf Start > Systemsteuerung > Benutzerkonten klicken und Kennwort für das eigene Konto erstellen anwählen. Passwort eingeben und bestätigen.

Hinweis: Durch das hinzufügen eines Passwortes wird nun jedes mal nach dem Ruhezustand oder beim Hochfahren nach dem Kennwort gefragt. Für die Eingabe beim Hochfahren gibt es allerdings einen Trick sodass man es nie wieder eingeben muss und der Computer immer direkt ins Konto startet.

Lösung: Klicke auf Start und gib ins Suchfeld netplwiz ein. Wähle nun das aktuelle Konto an, und entferne das Häkchen bei Benutzer müssen Benutzernamen und Kennwort eingeben. Nach einem klick auf Übernehmen sollte der Computer beim nächsten Starten nicht wieder nach dem Kennwort verlangen.

Nachdem die Passwort Angelegenheiten geklärt sind können wir endlich mit der Sicherung der DB beginnen. Dafür benötigen wir das Programm MySQL Administrator welches Bestandteil der MySQL GUI Tools ist. Am einfachsten die Windows (x86) Variante (aktuell Version 5.0-r17) auswählen und herunterladen.

Passwort Speicher
Sobald das Software Paket installiert ist, kann man den MySQL Administrator mit der Angabe der Datenbank Daten starten. Damit die Backups automatisch ablaufen, müssen die Passwörter für den Windows Benutzer Account und die MySQL Datenbanken gespeichert werden. Klicke dafür in der Menüleiste auf Tools gefolgt von Options. Aktiviere das Häkchen bei Store passwords und wähle für Password storage method die Option Obscured aus. Bestätige alles mit einem klick auf Apply und anschliessend Close.

Sicherungsprojekt erstellen
Nun zum Backup, klicke in der linken Spalte auf Backup und dann auf den Knopf New Project.Gib einen Namen für die Sicherung ein und füge zu sichernde Datenbanken mit eine klick auf den > Knopf hinzu. Sobald alle notwendigen DBs hinzugefügt wurden, kann auf den Tab Reiter Schedule geklickt werden um die Sicherungsintervalle festzulegen.

Sicherungsintervalle einstellen
Setze zuerst das Häkchen bei Schedule this backup project und gib den Pfad und den Dateinamen an unter welchem die MySQL Datei auf dem Computer abgelegt werden soll. Weiter unten findet man die ziemlich selbst erklärenden Einstellungen wo festgelegt werden kann wann und in welchen Abständen eine Sicherungskopie gemacht wird. Falls alle Variablen gemäss den individuellen Anforderungen eingestellt sind genügt ein klick auf Save und die Angabe des Passwortes des aktuellen Windows Benutzerkontos um die automatischen Backups zu aktivieren.

Tipp: Der Speicherort für die .sql Datei sollte falls möglich nicht auf dem C Laufwerk liegen, da das Backup sonst aus Grund ungenügender Rechte scheitern könnte.

Computer Backups sind wie gesunde Ernährung. Man verdrängt vergisst sie aus Bequemlichkeit bis es zu spät ist. Dabei wären zumindest Website Backups so einfach zu bewerkstelligen. Wie das genau geht werde ich in mehreren Teilen zeigen.

Um den Speicherplatz mit all den wichtigen Bildern und Dateien zu sichern bedienen wir uns des unter der GPL Version 3 Lizenz stehenden WGET Programms. Da WGET in C geschrieben ist, sollten ähnliche Backup Methoden mit diesem Programm auch auf anderen Betriebssystemen möglich sein. Der Einfachheit halber (und weil ich kein Mac besitze) werde ich hier jedoch nur die Sicherung unter Windows demonstrieren.

Zuerst einmal was ist eine Batch Datei?
Eine Batch Datei ist eine normale Text Datei mit der Endung .txt. Der einfachste Weg die Text Datei in eine Batch Datei zu verwandeln ist, diese in Notepad zu öffnen, und danach auf Datei > Speichern unter zu klicken. Im nun erscheinenden Dialog wählt man für Dateityp Alle Dateien (.) aus. Nun kann der neue Dateinamen mit der Endung .bat eingegeben werden. Bsp.: website-sicherung.bat. Danach auf Speichern klicken und man hat eine eigene Batch Datei erstellt.

Die Anweisungen, welche in die Batch Datei kommen sind aufgebaut wie folgt.
Wichtig: Es gilt alles auf nur eine Linie zu schreiben, da dies sonst als 2 verschiedene Befehle interpretiert wird.

{% highlight text %} [Speicherort der wget.exe Datei] -P[Speicherort der lokalen Website Kopie] ftp://[FTP Benutzername]:[FTP Passwort]@[FTP Domain] -m {% endhighlight %}

Speicherort der WGET Datei
Dabei gilt es zu beachten, dass falls der Pfad der WGET Datei Leerzeichen enthält, alles mit Anführungszeichen geschrieben werden muss ansonsten interpretiert der Computer die Zeichen nach dem ersten Leerzeichen als Variable für das Programm. Bsp.: "C:\wget ordner\wget.exe"

Speicherort der lokalen Website Kopie
Das Zeichen -P kennzeichnet den nachfolgenden Pfad als Speicherort für die heruntergeladenen Dateien. Es ist wichtig das kein Leerzeichen zwischen -P und dem Nachfolgenden Pfad ist, da WGET sonst annimmt der Speicherort sei Leer. Bsp.: -P"C:\website sicherung"

FTP
Nach dem Speicherort der Daten kommen die FTP Angaben. Da diese sehr unterschiedlich von der eigentlichen Website sein können, empfehle ich hier das jeweilige Datenblatt vom Hosting Anbieter anzuschauen. Bsp.: ftp://admin:passwort@ftp.example.com/

Kopierverfahren
Zum Schluss folgen die Zeichen -m, was bedeutet das ein Mirroring (exakte Kopie) erstellt wird.

Nachdem nun alle Parameter geklärt sind, kann das Beispiel Kommando zusammengesetzt werden.

{% highlight text %} "C:\wget ordner\wget.exe" -P"C:\website sicherung" ftp://admin:passwort@ftp.example.com/ -m {% endhighlight %}

Tipp für Windows Vista / 7 Benutzer: Falls die Website Kopie auf dem C Laufwerk gespeichert werden sollen, sind evt. Administrator Rechte notwendig.

Schritt 2 wird sich um das sichern der Datenbank drehen und nächsten Montag hier erscheinen.

Wer an der ETH Zürich studiert muss sich wärend seiner Zeit Punkte in Geisteswissenschaftlichen Fächern (sogenannten D-GESS) erarbeiten, damit soll das züchten von ahnungslosen Elite-Zombies verhindert werden. Um meine Punkte zu sammeln trug ich mich in das Pflichtwahlfach 'Digitale Nachhaltigkeit in der Wissensgesellschaft' von Marcus M. Dapp ein.  Getreu dem Motto, D-GESS ist nicht einfach eine weitere Vorlesung, war auch die Aufgabenstellung innerhalb des Semesters eine andere. Gefragt war eine Schriftliche Arbeit und eine dazugehörige Präsentation. Was natürlich schon Welten besser ist als die sonst üblichen Semester Prüfungen. Nach einigem Überlegen wählte ich die aktuelle Thematik rund um die Übernahme von Sun durch Oracle und was dies für Sun's OpenOffice.org (kurz OO.o) bedeuten wird. Ob eine Software Stiftung allenfalls in Frage kommt? Was sind andere erfolgreiche Stiftungen im Software Sektor? Was sind deren Vor- und Nachteile? - Dies und weitere Fragen werden sich hoffentlich nach dem lesen meiner Arbeit erübrigen (ca. 90kB). Zusätzlich sind unten auch die Slides eingebettet, jedoch leider ohne Ton, da ich den vergessen habe aufzunehmen (ist vielleicht auch besser so ;-)

Das Highlight war jedoch, als eine Woche später Simon Phipps von der OpenSource Abteilung von Sun Microsystems an der ETH zu Besuch war, und auch die Vorlesung besuchte. Da er weitestgehend derjenige ist, der Entscheiden muss / kann wie OO.o zukünftig behandelt wird. Leider konnte er sich nicht wirklich zu der Übernahme äussern da diese noch nicht abgeschlossen ist. Doch vermittelte er uns Anwesenden viel prektisches Wissen wie Firmen mit OpenSource umgehen, und damit trotz allen Widerständen gut Gewinn erzielt werden kann.

Korrektur
Wie Stephan in dem Forum Eintrag 'Zukunft von OpenOffice nach Sun-Übernahme' hingewiesen hat, kann eine bestehende GPL Lizenz (auch LPGL und dessen verwandte) nicht zurückgezogen werden. D.h. Oracle könnte die Lizenz der aktuellen, unter der GPL Lizenz erhältlichen, Version nicht ändern, sondern lediglich eine spätere Version unter einer neuen Lizenz veröffentlichen.

Am 16.-17.01.2010 war mein Zuhause ganz im Zeichen der Fasnacht. Über 4000 regionale und internationale kostümierte besuchten uns anlässlich des Landschaftstreffens und marschierten bei der über 3 stündigen Parade durch Siebnen (SZ) mit.

Die deutsche Hexengruppe (in den 2 letzten Bildern der Slideshow sichtbar) enterte sogar unseren Balkon indem sie über den Wasserabfluss Schacht hochkletterten.

Auch das Fernsehen von Tele Züri war mit Benno Kaelin anwesend und berichtete in den Abendnachrichten davon.

In der letzten Semesterwoche vor den Studienferien habe ich mich einem radikalen Test unterzogen. Die Idee war eine Woche nur mit Jolicloud OS zu arbeiten (wenigstens auf dem Laptop) um danach objektiv ein Urteil über das Produkt fällen zu können.

Zu allererst mussten natürlich passende Programme gefunden werden wie ich sie in der Windows Welt verwende. Trotz Wine das per Jolicloud problemlos installiert werden konnte brachte ich es nicht fertig Microsoft OneNote oder Windows Live Writer zu installieren, wäre wohl auch zu einfach gewesen ;-). Das Problem hätte mit einer virtuellen Windows Machine gelöst werden können. Jedoch virtuelle Maschine auf Netbook, keine besonders gute Idee! Daher musste ich wohl oder übel darauf verzichten.

Doch zum Glück gab es da noch Evernote, das sogar auch per Jolicloud installiert werden konnte. Naiv installierte ich es mit einem klick auf das schöne Evernote Icon, doch musste danach feststellen das dies lediglich ein Bookmark für Firefox war das auf Evernote.com verwies. Das ganze wäre nicht weiter schlimm, könnte ich ein Mobiles Internet Abo mein eigen nennen, ohne ist es dann aber einfach nur nutzlos. Evernote aufgeben stand noch nicht zur Debatte, so versuchte ich es mit der Evernote Beta Installation 3.5 unter Wine. Die Beta benötigte leider das .NET Framework 3.5 SP1 woran dann auch dieser Versuch scheiterte. Glücklicherweise funktionierte dann die letzte Variante, nämlich die finale 3.1 Version für Windows unter Wine. Zum schreiben genügt Evernote 3.1 gerade, doch brauchte es Aufgrund der Emulation viel mehr Batterie, hat komische PNG Fehler wie in IE6 und ist auch nicht sonderlich schnell. Daher entschied ich mich nach noch einer anderen Alternative zu suchen.

OpenOffice.org im Zusammenhang mit Dropbox war die nächstliegende und vermutlich beste Wahl. Die 1-Klick installation per Jolicloud funktionierte Problemlos und auch Dropbox lies sich ohne murren einrichten.

Nebenbei auch das Team von Jolicloud findet diese Lösung genial, sodass sie sie ausbauen wollen wie, im Interview mit Techcrunch Michael Arrington, verkündet wurde (Video unten).

Bezüglich der Geschwindigkeit kann ich nur bedingt Auskunft geben, da Jolicloud auf einem 16GB USB Stick installiert wurde und nicht wie normalerweise auf der internen Festplatte. Auch die Hardware ein HP 2710P (obwohl schon 1.5 Jahre alt) liegt in der Leistungsklasse einiges höher als ein Durchschnitts-Netbook.

Die Startzeiten bei meiner Konstellation ist bei ca. 40 Sekunden verglichen mit dem Windows 7 das auf der internen Festplatte installiert ist und ca. 50 Sekunden benötigt. Jolicloud muss glücklicherweise nach dem hochfahren nicht mehr unnötig Programme oder deren Teile nachladen, sodass angeklickte Programme starten wie wenn der Computer schon einige Zeit gelaufen wäre. (Was ja bei Windows nicht immer der Fall ist ;-)
Das allerdings auch Jolicloud nicht perfekt ist zeigte sich, als ich den Standby oder Ruhezustand Betrieb wechseln wollte. Die Abschaltphase dauerte ungefähr so lange wie wenn man den Computer ganz herunterfahren wollte. Der spätere Warm-Start benötigte danach ungefähr so lange wie wenn man den Computer kalt neustartete. Somit verstehe ich nun auch endlich warum die meisten Mitstudenten die Linux verwenden ihre Laptops immer herunterfahren.

Nachdem man das eine Passwort zum starten der Machine verwendet hat, wird beim starten der Jolicloud Anwendung wiederum nach einem anderen Passwort gefragt. Das ganze ist völlig verständlich, da die Jolicloud Anwendung eine Webseite ist die im modifizierten Firefox geöffnet wird. Allerdings wiederspricht das meinem Verständnis von Cloud OS massiv. Wenn die Jolicloud Entwickler schon den Firefox modifizieren sollten sie sicherlich auch in der Lage sein diesen Prozess zu vereinfachen. Oder worin sollte sonst der Unterschied zwischen einem normalen Linux und dem Jolicloud bestehen?

Dies habe ich mich die ganze Woche ohne Ergebnis gefragt. Bin jedoch offen für Vorschläge.

In dieser Woche wurde mir bewusst, dass ich trotz der Abhängigkeit vom Internet nicht alles nur per Internet erledigen kann resp. will. Gerade Backup Katastrophen in der jüngsten Vergangenheit sollten uns doch darauf hinweisen, dass es eine Firma relativ wenig stört wenn Benutzerdaten verloren gehen, dies andererseits für Benutzer weniger der Fall sein wird.

Mein Scanner, ein Canon CanoScan 8800F hat direkt auf dem Deckel verschiedene Direktwahl-Tasten, damit man beim scannen nicht immer zum Computer und wieder zurück rennen muss. Was ganz nett klingt hat unter Windows Vista / 7 mit installiertem Photoshop allerdings so seine Tücken. Nach dem drücken der Schnellwahltaste für PHOTO/FILM erscheint auf dem Computer eine Auswahl Box in welcher MP Navigator EX Ver1.0 angewählt werden muss damit der Scanvorgang endlich startet.

Soviel zur Ausgangslage, nun zu den Lösungen des Problems. Zuerst sollte der Scanner angeschaltet sein. Dann geht man auf Start > Geräte und Drucker.

Hier klickt man rechts auf den Scanner und wählt Scaneigenschaften an.

Nun kann man das gewünschte Ereignis auswählen, in meinem Fall CanoScan PHOTO/FILM Button und das Programm welches gestartet werden soll falls die PHOTO/FILM Taste auf dem Scanner gedrückt wird.

Nun kommen wir zum zweiten Problem, nach dem drücken auf OK erscheint nämlich die Meldung Fehler beim Registrieren des Ereignisses.

Dies ist ein Berechtigungsproblem und kann gelöst werden indem man die Windows Taste drückt und regedit eingibt, um den Registry Editor aufzurufen.

Warnung In der Registry ist Vorsicht geboten, da falsche Änderungen, neu aufsetzen des Betriebssystems bedeuten können.

In der Registry geht sucht man den obersten Knoten HKEYLOCALMACHINE und danach die folgenden Unterknoten SYSTEM > CurrentControlSet > Control > Class. Ab hier stehen nur noch vom Computer generierte Namen und diese können bei jedem Computer anders sein. Daher muss der Knoten Class angeklickt werden. Nun wählt man oben Bearbeiten > Suchen an, und schreibt ins Suchfeld imaging devices. Nach dem Klick auf Suchen öffnet sich ein Ordner. (wie unten im Bild)

Nach einem Rechtsklick auf diesen Ordner (in meinem Fall {6BDD1FC6-810F-11D0-BEC7-08002BE2092F} ) wählt man die Option Berechtigungen…

Klickt unter Gruppen- und Benutzernamen, Benutzer an und setzt den Hacken bei Vollzugriff Zulassen. Nach dem Übernehmen der Änderungen sollte nun auch das Zuweisen der verschiedenen Programme funktionieren sodass bei einem Klick auf die Scantaste auch wirklich das Scanprogramm auf dem Computer startet und auch effektiv Zeit eingespart werden kann.

Nick Baker, General Manager für das Xbox Architektur Design Team stand Robert Hess dem Mann hinter der Studio Sendung von Microsoft, Behind the Code, eine Stunde lang rede und Antwort, was seine Karriere und die Xbox Architektur angeht. Sehr interessant was man mit einem Master in Electrical Engineering and Information Technology alles erreichen kann.

Yesterday my ZuneHD was delivered straight from the US. But unfortunately I wasn’t able to sync it with my computer (German Windows 7). After some research I stumbled upon this forum thread in anythingbutipod.com (Zune Hd first sync) which gave which gave me the solution.

My ZuneHD was shipped with firmware 4.0 which only support English, Spanish and French Windows language. To upgrade it you will either have to use an Windows XP / Vista / Windows 7 with English OS language or download and install the English Language Pack (I haven’t done this, but it was mentioned in the forum thread).

After the firmware update is on the device (currently 4.3) you should be able to plug it in any Windows computer no matter what the language of the OS is. (if you use the Zune Marketplace Registry Hack you have to set the region option to US)

If you’ve installed Visual Studio 2008 on an x64 Windows Computer you may getting into trouble trying to install Service Pack 1. First of all you will get an error message (Error 1324) which will tell you that Program Files contains an invalid character. After the installation finished you can access the log file. (shown below)

In there select the link (marked yellow).

And now search for pfiles. You will find something like G:\PFiles. On my computer G was a virtual drive. So the solution was to deactivate all virtual and physical read-only drives and then try the installation all over again. This time it worked seamlessly.

Nun ist es wieder einmal soweit, und ich eröffne voller stolz mein neues, persönliches, virtuelles Tagebuch.

Mein anderer Blog www.enlightentheweb.com hat mich in letzter Zeit thematisch zu stark eingeschränkt, sodass ich seit geraumer Zeit gar nichts mehr veröffentlichte. Als Ausgleich twitterte ich aktiv, was auf die Dauer nicht wirklich befriedigend ist, da einem die 140 Zeichen doch stärker zusetzen. Aus diesem und anderen Gründen habe ich nun diesen Blog ins Leben gerufen, auf dem ich über persönliche und andere Interessante Dinge berichten kann, ohne dass mich dabei etwas einschränkt.

www.enlightentheweb.com wird irgendwann in nächster Zeit gelöscht, einige populäre Artikel werden jedoch erhalten bleiben. Ich werde diese erneuern und danach hier integrieren.

Es wäre daher schön wenn du diesen Blog abonnieren würdest, und ab und zu einen Kommentar abgibst.