Planet NoName e.V.

19. August 2014

Atsutane's blog

FrOSCon 2014

For those who may miss to see us people downstairs next to some other distro/BSD: This year Arch Linux has its own room at FrOSCon, you’ll find us people in C125.

19. August 2014 05:42:49

12. August 2014

Mero’s Blog

Applying permutation in constant space (and linear time)

I stumbled upon a mildly interesting problem yesterday: Given an Array a and a permutation p, apply the permutation (in place) to the Array, using only O(1) extra space. So, if b is the array after the algorithm, we want that a[i] == b[p[i]].

Naively, we would solve our problem by doing something like this (I'm using go here):

func Naive(vals, perm []int) {
    n := len(vals)
    res := make([]int, n)
    for i := range vals {
        res[perm[i]] = vals[i]
    }
    copy(vals, res)
}

This solves the problem in O(n) time, but it uses of course O(n) extra space for the result array. Note also, that it does not really work in place, we have to copy the result back.

The simplest iteration of this, would be to simply use a sorting-algorithm of our choice, but use as a sorting key not the value of the elements, but the position of the corresponding field in the permutation array:

import "sort"

type PermSorter struct {
    vals []int
    perm []int
}

func (p PermSorter) Len() int {
    return len(p.vals)
}

func (p PermSorter) Less(i, j int) bool {
    return p.perm[i] < p.perm[j]
}

func (p PermSorter) Swap(i, j int) {
    p.vals[i], p.vals[j] = p.vals[j], p.vals[i]
    p.perm[i], p.perm[j] = p.perm[j], p.perm[i]
}

func Sort(vals, perm []int) {
    sort.Sort(PermSorter{vals, perm})
}

This appears a promising idea at first, but as it turns out, this doesn't really use constant space after all (at least not generally). The go sort package uses introsort internally, which is a combination of quick- and heapsort, the latter being chosen if the recursion-depth of quicksort exceeds a limit in O(log(n)). Thus it uses actually O(log(n)) auxiliary space. Also, the running time of sorting is O(n log(n)) and while time complexity wasn't part of the initially posed problem, it would actually nice to have linear running time, if possible.

Note also another point: The above implementation sorts perm, thus destroying the permutation array. Also not part of the original problem, this might pose problems if we want to apply the same permutation to multiple arrays. We can rectify that in this case by doing the following:

type NDPermSorter struct {
    vals []int
    perm []int
}

func (p NDPermSorter) Len() int {
    return len(p.vals)
}

func (p NDPermSorter) Less(i, j int) bool {
    return p.perm[p.vals[i]] < p.perm[p.vals[j]]
}

func (p NDPermSorter) Swap(i, j int) {
    p.vals[i], p.vals[j] = p.vals[j], p.vals[i]
}

func NDSort(vals, perm []int) {
    sort.Sort(NDPermSorter{vals, perm})
}

But note, that this only works, because we want to sort an array of consecutive integers. In general, we don't want to do that. And I am unaware of a solution that doesn't have this problem (though I also didn't think about it a lot).

The solution of solving this problem in linear time lies in a simple observation: If we start at any index and iteratively jump to the target index of the current one, we will trace out a cycle. If any index is not in the cycle, it will create another cycle and both cycles will be disjoint. For example the permutation

i    0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19
p[i] 2  13 1  5  3  15 14 12 8  10 4  19 16 11 9  7  18 6  17 0

will create the following set of cycles:

So the idea is to resolve every cycle separately, by iterating over the indices and moving every element to the place it belongs:

func Cycles(vals, perm []int) {
    for i := 0; i < len(vals); i++ {
        v, j := vals[i], perm[i]
        for j != i {
            vals[j], v = v, vals[j]
            perm[j], j = j, perm[j]
        }
        vals[i], perm[i] = v, i
    }
}

This obviously only needs O(1) space. The secret, why it also only uses O(n) time lies in the fact, that the inner loop will not be entered for elements, that are already at the correct position. Thus this is (from a complexity standpoint at least) the optimal solution to the problem, as it is impossible to use less than linear time for applying a permutation.

There is still one small problem with this solution: It also sorts the permutation array. We need this, to know when a position is already occupied by it's final element. In our algorithm this is represented by the fact, that the permutation is equal to it's index at that point. But really, it would be nice if we could mark the index without losing the order of the permutation. But that is not hard either - because every index is non-negative, we can simply negate every index we are done with. This will make a negative index out of it and we can check for that if we encounter it later and skip it in this case. After we are done, we only need to take care to flip everything back and all should be fine:

func NDCycles(vals, perm []int) {
    for i := 0; i < len(vals); i++ {
        if perm[i] < 0 {
            // already correct - unmark and go on
            // (note that ^a is the bitwise negation
            perm[i] = ^perm[i]
            continue
        }

        v, j := vals[i], perm[i]
        for j != i {
            vals[j], v = v, vals[j]
            // When we find this element in the future, we must not swap it any
            // further, so we mark it here
            perm[j], j = ^perm[j], perm[j]
        }
        vals[i] = v
    }
}

Here we only mark the elements we will again encounter in the future. The current index will always be unmarked, once we are done with the outer loop.

I am aware, that this is technically cheating; This solution relies on the fact, that the upper-most bit of the permutation elements won't ever be set. Thus, we actually do have O(n) auxiliary space (as in n bit), because these bits are not necessary for the algorithm. However, since it is pretty unlikely, that we will find an architecture where this is not possible (and go guarantees us that it actually is, because len(vals) is always signed, so we cant have arrays that are big enough for the msb being set anyway), I think I am okay with it ;)

I ran sum Benchmarks on this an these are the figures I came up with:

n 10 100 1000 10000
Naive 332 ns 883 ns 15046 ns 81800 ns
NDCycle 130 ns 1019 ns 17978 ns 242121 ns
NDSort 1499 ns 27187 ns 473078 ns 4659433 ns

I did not measure space-use. The time of NDCycle for 10000 elements seems suspicious - while it is not surprising, that in general it takes more time than the naive approach, due to it's complexity, this jump is unexpected. Maybe if I have the time I will investigate this and also measure memory use. In the meantime, I uploaded all the code used here, so you can try it out yourself. You can run it with go run perm.go and run the benchmarks with go test -bench Benchmark.*.

12. August 2014 11:10:21

11. August 2014

Moredreads Blog

Werbungskritik

Normalerweise kommentiere ich wenig im Netz, da die Diskussionskultur durch Trolle und anderes ziemlich schlecht ist. Und so sicher bin ich mir nicht mit dem was ich denke, dass ich das anderen aufbürden wollte. :p

Aber trotzdem habe ich mal zu “Das Experiment”, einem Gastbeitrag auf zu der Stimmungsmanipulationsstudie von Facebook, einen Kommentar (sogar mit Klarnamen oO) verfasst, und damit meine lange Abstinenz von öffentlichen Diskussionen abseits Twitter etc. gebrochen. Vielleicht liest’s ja jemand und findet es nachdenkenswert. :p

Um diesen Beitrag ein wenig mit Inhalt zu füllen, vielleicht noch eine Ergänzung.

Ich finde es sehr bemerkenswert wie normal Werbung wahrgenommen wird, als sei es ein Gott-gegebenes Recht von Unternehmen zu “Käufern” degradierte Bürger zum Kauf ihrer Waren zu bewegen, wobei nur in Grenzfällen gesetzliche Hürden gesetzt werden (i. B. bei an Kinder gerichtete Werbung und ironischer Weise, wenn Sie andere Unternehmen zu stark betrifft (Unlauterer Wettbewerb)).

Im Gegensatz zu Kindern, von denen angenommen wird, dass sie nicht fähig sind, den “Wahrheitsgehalt” von Werbung zu durchschauen, wird dem/der Erwachsenen eine “Mündigkeit” als Verbraucher zugeschrieben, bewusst und mit Bedacht das Warenangebot zu betrachten, bevor er/sie eine Entscheidung trifft. Von einem logischen und rationalem Marktteilnehmer/-Innen gehen auch “der” Neoliberalismus aus, dessen Ideologie seit Jahrzehnten immer mehr die Wirtschaftspolitik geprägt hat.

Alleine die Existenz von Werbung müsste dieses Weltbild ins Wanken bringen, denn es ist vielerlei in Studien (sorry, müsst selber suchen :p) gezeigt worden, dass auch darauf achtende Menschen leicht von ihr beeinflussbar sind, und insbesondere in der Überflutung von verschiedensten Informationen nicht alle in den Entscheidungsprozess einfließen lassen können. Aber Marketing, public relations, Lobbying etc. wird auch gerade von Anhängern des Marktliberalismus betrieben, wobei die “Initiative Neue Soziale Marktwirtschaft” und die Bertelsmann-Stiftung nur zwei prominente Akteure sind. Kritik an nicht rein informatinsbasierter “Öffentlichkeitsarbeit”, sei es durch Unternehmen, Lobbyisten, oder anderen “Marktteilnehmern”, kenne ich von Markt-liberalen nicht. Das das keine signifikante kognitive Dissonanz auslöst…

Auch ist Werbung in meinen Augen ein signifikantes Volkswirtschaftliches Problem. Alleine die direkte Investition in Werbung beträgt ca. 1% des Bruttoinlandprodukts in Deutschland, oder ca. 30 Milliarden Euro; vermutlich sind darin indirekte Investitionen, wie interne Produktoptimierungen nicht enthalten. Dies ist Produktivkraft, die verschwendet wird, um alleine das Konsumverhalten zu lenken.

Gerade sozial wichtige Bereiche sind hiervon Betroffen, z.B. fließen bei Pharma-Konzernen große Mengen in Werbung, teils mehr als in Forschung und Entwicklung (siehe z.B. diesen Spiegel Artikel). Dabei ist noch nicht berücksichtigt, dass die Grundlagenforschung die Innovationen erst ermöglicht, größtenteils aus öffentlichen Mitteln finanziert wird. Des weiteren wird durch Lobbying versucht besonderer Schutz fuer Pharma-Unternehmen durch internationale Abkommen zu erreichen, um z.B. den großen Generika Markt in Indien, von dem u. A. Staaten in Afrika stark profitieren, zu sabotieren. (Eine humorige Entgleisung eines Pharmavertreters ist hier ein Interview geführt von Martin Sonneborn)

Dies nur so als ein Paar Beispiele warum ich es, wie Eingangs erwähnt, bemerkenswert finde, dass Werbung eine so prominente Stellung in unserer Gesellschaft einnehmen kann. Andere kritische Beispiele finden sich z. B. in den Werken von Noam Chomsky, aber auch Systemtragende sollten Grund haben da sich zu wundern.

11. August 2014 19:15:00

sECuREs Webseite

Configuring a Ubiquiti EdgeRouter Lite (Erlite-3) for Fiber7

Configuring a Ubiquiti EdgeRouter Lite (Erlite-3) for Fiber7

Geschrieben von: Michael am 11.08.2014

I immediately ordered a fiber7 internet connection once it became available, and I’ve been connected since a few weeks. They offer a 1 Gbps symmetrical fiber connection, with native (static) IPv6 and no traffic limit — for 65 CHF per month (about 54 €).

In the order form, they let you choose whether you want to order a pre-configured MikroTik RB2011UiAS-2HnD including fiber optic and fiber patch cable. I assumed this would be an excellent choice, so I ordered it.

I really like the MikroTik device. Its CLI and web interface are well thought-out and easy to use once you understand their way of thinking. It’s small, absolutely silent and just works. However, there’s one shortcoming: it doesn’t do IPv4 hardware acceleration (they call it “fast path”) when you enable NAT, which you need for a fiber7 connection. Thus, the top bandwidth maxes out at 500 to 600 Mbps, so effectively you only use half of your available bandwidth.

Therefore, I looked around for other routers which can do a full Gigabit WAN-to-LAN, i.e. with IPv4-NAT enabled. The selection of routers that can do that is very small, see for example the smallnetbuilder WAN-to-LAN router charts.

In my first try, I went with the Netgear R7000 (“Nighthawk”) which is the highest-performing router with regards to WAN-to-LAN bandwidth on smallnetbuilder. It indeed does hardware acceleration for IPv4-NAT, so you can reach the full 118 MB/s TCP bandwidth that a Gigabit line offers. However, the firmware does not do DHCPv6-PD (Prefix Delegation), even though it’s certified as IPv6-ready. There are alternative firmwares, e.g. Tomato and DD-WRT. Tomato (v121 as of writing) comes with the kernel module that enables IPv4-NAT hardware acceleration, but has a nasty bug: the latency jumps up to 500ms for most of your packets, which is clearly not acceptable. DD-WRT does not come with such a kernel module because they use a newer kernel, so the speed maxes out at 400 Mbps (that’s what they claim, I didn’t even bother testing it).

Ubiquiti EdgeRouter Lite (Erlite-3)

So, as a second try, I ordered what everyone recommended me in the first place: the Ubiquiti EdgeRouter Lite (Erlite-3).

The EdgeRouter Lite (with firmware v1.5.0) offers IPv4 and IPv6 offloading, and in fact reaches Gigabit line rate (118 MB/s measured TCP performance). An unwelcome surprise is that hardware acceleration only works when not using bridging at all, so if you want to connect two devices to your router in the same subnet, like a computer and a switch, you cannot do that. Effectively, the EdgeRouter needs to sit between the internet connection and a switch.

With regards to the web interface of EdgeOS: the web interface feels very polished and modern, but it seems to lack a number of features that are only accessible in the CLI interface. The MikroTik web interface had a much higher coverage of features. In general, I like how Ubiquiti does many things right, though: firmware updates are quick and painless, the model selection and download on their website is very simple to find and use, and you even get a link to the relevant GPL tarball without asking :).

Configuring the EdgeRouter Lite for fiber7

First of all, you should disconnect the MikroTik (or your current router) from the network. I recommend doing that by explicitly disabling both DHCP clients, so that the fiber7 router knows you are not using the old device any more. This is important because fiber7 uses a Cisco feature called “IP source guard”, which will disable any MAC address on your port that does not have a DHCP lease. Therefore, if you just switch routers, you need to wait for the old lease to expire before you get a new lease. In my first tests, this worked relatively well, but then a lease got stuck for some reason and I had to escalate the problem to their NOC. So, better disable the DHCP:

/ip dhcp-client set disabled=yes numbers=0
/ipv6 dhcp-client set disabled=yes numbers=0

In my configuration, I connect a switch to eth0 and a media converter (the TP-LINK MC220L) to eth1. As a general tip: if you mess up your configuration, you can always use the link-local address of the EdgeRouter and SSH into that. Find the link-local address using ping6 ff02::1%eth0.

After logging into the web interface, set the eth1 address to DHCP and it should get a public IPv4 address from fiber7. Afterwards, enable NAT by clicking on NAT → Add Source NAT Rule. Set the outbound interface to eth1 and select the “masquerade” radio button. You’ll also need to switch to the “services” tab and enable a DHCP and DNS server. This should give you IPv4 connectivity to the internet.

IPv6 is a bit harder, since EdgeOS in its current version (1.5.0) does not support DHCPv6-PD via its Web or CLI interface. The necessary software (wide-dhcpv6) is included, though, so we can configure it manually.

Use ssh ubnt@192.168.1.1 to log into the CLI. In order to set the proper IPv6 address on the transfer network, run ip -6 address show dev eth1 and look for a line that says inet6 fe80::de9f:dbff:fe81:a906/64 scope link. Copy everything after the :: and prefix it with 2a02:168:2000:5: (the fiber7 transfer network range), then configure that as static IPv6 address on eth1 and set the default route (and enable IPv6 offloading):

configure
set system offload ipv6 forwarding enable
set interfaces ethernet eth1 address 2a02:168:2000:5:de9f:dbff:fe81:a906/64
set protocols static route6 ::/0 next-hop 2a02:168:2000:5::1 interface eth1
commit
save
exit

Now you should be able to run ping6 google.ch and get a reply. We still need to enable DHCPv6 though so that the router gets a prefix and hands that out to its clients. Run sudo -s to get a root shell and configure DHCPv6:

cat >/etc/wide-dhcpv6/dhcp6c-script-zkj <<'EOT'
#!/bin/sh
# wide-dhcpv6-client 20080615-12 does not properly close
# file descriptors when starting the script.
# https://bugs.debian.org/757848
exec 4>&- 5>&- 6>&- 7>&-
# To prevent radvd from sending the final router advertisment
# that unconfigures the prefixes.
killall -KILL radvd
/etc/init.d/radvd restart
exit 0
EOT
chmod +x /etc/wide-dhcpv6/dhcp6c-script-zkj

cat >/etc/wide-dhcpv6/dhcp6c.conf <<'EOT'
interface eth1 {
        send ia-pd 0;
        request domain-name-servers;
        script "/etc/wide-dhcpv6/dhcp6c-script-zkj";
};

id-assoc pd 0 {
        prefix-interface eth0 {
                sla-id 1;
                sla-len 0;
        };
};
EOT

sed -i 's/eth0/eth1/g' /etc/default/wide-dhcpv6-client

cat >/config/scripts/post-config.d/dhcpv6.sh <<'EOT'
#!/bin/sh
/etc/init.d/wide-dhcpv6-client start
EOT
chmod +x /config/scripts/post-config.d/dhcpv6.sh

/config/scripts/post-config.d/dhcpv6.sh

Now, when running ip -6 address show dev eth0 you should see that the router added an IPv6 address like 2a02:168:4a09:0:de9f:dbff:fe81:a905/48 to eth0. Let’s enable router advertisments so that clients get an IPv6 address, route and DNS server:

configure
set interfaces ethernet eth0 ipv6 router-advert prefix ::/64
set interfaces ethernet eth0 ipv6 router-advert radvd-options
  "RDNSS 2001:4860:4860::8888 {};"
commit
save
exit

That’s it! On clients you should be able to ping6 google.ch now and get replies.

Bonus: Configuring a DHCPv6-DUID

fiber7 wants to hand out static IPv6 prefixes based on the DHCPv6 option 37, but that’s not ready yet. Until then, they offer you to set a static prefix based on your DUID (a device identifier based on the MAC address of your router). Since I switched from the MikroTik, I needed to port its DUID to the EdgeRouter to keep my static prefix.

Luckily, wide-dhcpv6 reads a file called dhcp6c_duid that you can create with the proper DUID. The file starts with a 16-bit integer containing the length of the DUID, followed by the raw DUID:

echo -en '\x00\x0a\x00\x03\x00\x01\x4c\x5e\x0c\x43\xbf\x39' > /var/lib/dhcpv6/dhcp6c_duid

Conclusion

I can see why fiber7 went with the MikroTik as their offer for customers: it combines a media converter (for fiber to ethernet), a router, a switch and a wifi router. In my configuration, those are now all separate devices: the TP-LINK MC220L (27 CHF), the Ubiquiti EdgeRouter Lite Erlite-3 (170 CHF) and the TP-LINK WDR4300 (57 CHF). The ping latency to google.ch has gone up from 0.6ms to 0.7ms due to the additional device, but the download rate is about twice as high, so I think this is the setup that I’ll keep for a while — until somebody comes up with an all-in-one device that provides the same features and achieves the same rates :-).

by Michael Stapelberg at 11. August 2014 09:55:00

31. July 2014

RaumZeitLabor

Mario Kart Turnier #7

Ladys, Gentlemen, Koopa, Pilzköpfe und sonstige Entitäten!
Es ist wieder soweit, das RaumZeitLabor lädt ein zum 7. Mario Kart Turnier! Egal ob ihr alle Strecken im Schlaf beherrscht oder noch nie mit einem Kart eure Runden gedreht habt: Fahrerinnen und Fahrer aller Erfahrungsstufen sind willkommen!

Wir werden das Turnier in den Disziplinen Super Mario Kart (Super Nintendo) und Mario Kart 64 (Nintendo 64) im Doppel-K.O.-System austragen. Je nach Anzahl der Teilnehmer wird es auch eine Gruppenphase geben. Das Turnier findet am Samstag, den 23. August 2014 statt. Die Teilnahme ist kostenfrei, ihr müsst euch aber bis spätestens 19h im RaumZeitLabor eingefunden haben. Zur weiteren Planung wäre es toll, wenn ihr euch mit einem Kommentar unter diesem Blogpost oder auf der Facebookseite anmeldet.

Als kleines Warm-Up hier das Finale des letzten Turniers zwischen Jannik (Bowser, oben) und Cheatha (Wario, unten):

by Cheatha at 31. July 2014 19:33:50

29. July 2014

RaumZeitLabor

Ludum Dare 30 im RaumZeitLabor

Am Wochenende vom 22-25 August 2014 findet zum 30. Mal der internationale Gamejam “ludum dare” statt. Um 3 Uhr in der Nacht von Freitag auf Samstag fällt der Startschuss, alleine in 48 oder als Team in 72 Stunden ein Spiel zu einem vorgegebenen Thema zu programmieren.

Wer keine Lust hat, in Einsamkeit zu programmieren oder schon immer mal jemandem beim Spiele programmieren zuschauen wollte, ist eingeladen, im RaumZeitLabor vorbeizukommen.

Bei gutem Wetter wird auch gegrillt!

Anfahrt

by xAndy at 29. July 2014 17:32:58

28. July 2014

sECuREs Webseite

Don’t type WiFi passwords again: use a yubikey

Don’t type WiFi passwords again: use a yubikey

Geschrieben von: Michael am 28.07.2014

In my flat, I have a printed QR code which contains the WiFi credentials. You can scan it with your Smartphone (provided you have a barcode scanner installed) and then connect to the WiFi network.

For notebook computers, this doesn’t work so well. Sometimes they don’t have a usable camera, and even if they have one, people don’t typically have a barcode scanner installed.

Therefore, you typically end up typing in the (long) password, which is annoying. I thought there should be a better way, perhaps by faking a USB Human Interface Device (like a keyboard). Then I saw a YubiKey lying around and a couple minutes later I had my solution working :-).

YubiKey

YubiKey

The YubiKey is a small USB device (about as big as a USB memory stick) that is typically used for two-factor authentication. You may be familiar with this concept from Gmail, where you log in with a password and then provide a number generated by the Google Authenticator on your phone as a second factor. The YubiKey does this by simulating you typing in the number after you touch it.

Luckily, the device’s firmware also supports a mode where it essentially just types a static password when being touched. Unfortunately, this feature is a bit hard to use, so I wrote pw-to-yubi, a little script which translates a (WiFi) password into a command line to program your YubiKey.

$ sudo apt-get install yubikey-personalization
$ git clone https://github.com/stapelberg/pw-to-yubi.git
$ cd pw-to-yubi
$ ./pw-to-yubi.pl mywifipassword
ykpersonalize -1 -o-append-cr -o-static-ticket -oshort-ticket \
  -o-strong-pw1 -o-strong-pw2 -oman-update \
  -ofixed=h:101c1a0c090c130416161a1215070000 -ouid=000000000000 \
  -a00000000000000000000000000000000

Run the command and any further touches of the YubiKey that is currently plugged into your computer will result in the key typing your WiFi password.

pw-to-yubi in a terminal emulator

by Michael Stapelberg at 28. July 2014 19:15:00

26. July 2014

Moredreads Blog

19. July 2014

Moredreads Blog

14. July 2014

RaumZeitLabor

Zweiter Agenda Diplom 2014 Workshop

Nach dem erfolgreichen Start im Mai fand am vergangenen Wochenende der zweite Termin des „Agenda Diplom für Kinder“ der Stadt Mannheim im RaumZeitLabor statt. Unter dem Motto „Wir erwecken Roboter zum Leben“ haben wir erneut mit drei Gruppen von acht- bis zwölfjähriger Kinder Lego-Mindstorms-Roboter programmier, mit Aufgaben steigenden Schwierigkeitsgrades.

IMG_6393b

IMG_6402b

IMG_6408b

IMG_6417b

IMG_6426b

IMG_6456b

IMG_6464b

IMG_6473b

IMG_6450b

IMG_6465b

IMG_6483b

IMG_6489b

by rami at 14. July 2014 18:13:12

04. July 2014

Moredreads Blog

22. June 2014

Mero’s Blog

GPN14 GameJam - Crazy cat lady

tl:dr: We made a gamejam-game

At the GPN14 we (meaning me and Lea, with a bit of help by sECuRE) participated in the gamejam. It was the first time for us both, I did all the coding and Lea provided awesome graphics.

The result is a small minigame “crazy cat lady”, where you throw cats at peoples faces and - if you hit - scratch the shit out of them (by hammering the spacebar). The game mechanics are kind of limited, but the graphics are just epic, in my opinion:

Screenshot

Because sounds make every game 342% more awesome, we added a creative commons licensed background-music. We also wanted some cat-meowing and very angry pissed of hissing, which was more of a problem to come by. Our solution was to just wander about the GPN and asking random nerds to make cat sounds and recording them. That gave a pretty cool result, if you ask me.

On the technical side we used LÖVE, an open 2D game engine for lua, widely used in gamejams. I am pretty happy with this engine, it took about 3 hours to get most of the game-mechanics going, the rest was pretty much doing the detailed animations. It is definitely not the nicest or most efficient code, but for a gamejam it is a well suited language and engine.

If you want to try it (I don't think it is interesting for more than a few minutes, but definitely worth checking out), you should install LÖVE (most linux-distributions should have a package for that) and just download it, or check out the sourcecode.

We did not make first place, but that is okay, the game that won is a nice game and a deserved winner. We had a lot of fun and we are all pretty happy with the result as first-timers.

22. June 2014 13:45:28

13. June 2014

Moredreads Blog

06. June 2014

Moredreads Blog

15. May 2014

sECuREs Webseite

Horrible WiFi in hotels

Horrible WiFi in hotels

Geschrieben von: Michael am 16.05.2014

I’ve been travelling a bit to foreign countries lately and noticed that all of the places I’ve stayed at (low to medium price range hotels) have one thing in common: their WiFi is absolutely horrible.

Even worse, it seems like the more money you pay, the more horrible the WiFi gets. As an example, I’ve stayed at the NH city centre in Amsterdam recently. Curiously, swisscom runs the WiFi there — I didn’t even know they do more than access and mobile network in Switzerland. We booked a double room (so the hotel knew there are two people staying in the room), but swisscom only allows one login. I’ll repeat: one (1) login. In 2014. Where people travel with smartphones, tablets and notebooks. Per person. Even better: every time you lose connection, you need to re-acknowledge the terms of service. Of course this breaks automated updates of Android smartphones because they try to save battery and connect to the WiFi only sporadically.

Not only with swisscom it frequently happens that WiFi providers offer you laughably low volume limits like 100 MiB, which is less than what I have with my tiny international roaming package. Or 256 kbit/s (!) of bandwidth, which of course is no comparison to mobile data connections these days. Also, I’ve seen latencies as high as half a minute, effectively preventing any internet usage from working.

The horrible WiFi PDF

In order to not suffer in silence any more, but quickly express my frustration, I’ve created a form that I’ll carry with me when visiting a hotel. In case (hah!) their WiFi sucks, I can just leave them that note and hope they’ll eventually take action.

Feel free to do the same: store horrible-wifi.pdf (19 KiB) (Public Domain, please share) and leave it at every hotel with inacceptable WiFi.

by Michael Stapelberg at 15. May 2014 23:30:00

13. May 2014

RaumZeitLabor

Roboter erfolgreich zum Leben erweckt – Agenda Diplom 2014 im RaumZeitLabor startet mit großem Interesse

Nach dem großen Zuspruch beim Agenda Diplom für Kinder der Stadt Mannheim im letzten Jahr nimmt das RaumZeitLabor auch in diesem Jahr wieder mit vier Veranstaltungen unter dem Motto “Wir erwecken Lego-Roboter zum Leben – Deine ersten Schritte mit Lego Mindstorms EV3 Robotern” teil.

agenda19 agenda18
agenda20

Der erste Termin am 10. Mai war im Nu ausgebucht, bei den restlichen Terminen sind augenblicklich nur noch wenige Plätze frei.

Pünktlich um 15 Uhr waren sowohl 12 Mädchen und Jungs, als auch eine stattliche Anzahl interessierter Eltern im RaumZeitLabor, um zu erfahren wie man Lego Roboter mit dem System Mindstorms EV3 zum Leben erwecken kann. Dabei ging es primär darum den programmierbaren Elementen beizubringen Abläufe in der richtigen Reihenfolge zu vollführen, damit eine selbst gestellte Aufgabe bewältigt werden konnte.

agenda17

Es brauchte nur einen ganz kurze Einführung und schon sah man die Kinder, die sich in drei Teams zusammengefunden hatten, zusammen erste Schritte zur Aufgabenstellung zu diskutieren und diese dann auch sofort im Programmiersystem von Lego Mindstorms EV3 umzusetzen.

agenda16 agenda15 agenda14 agenda07 agenda06 agenda05

Aber nicht nur die Kids waren fasziniert von der Materie, nein, auch die mitgekommennen Eltern erhielten ihrerseits Einblicke in das was ihre Kinder, draußen, in einem anderen Raum, gerade machten und waren begeistert. Für Sie gab es nämlich einen kleinen Extra Workshop im angrenzenden Workshopraum des RaumZeitLabors. Sie wurden sowohl über die Möglichkeiten des Lego Systems informiert, als auch über das was man sonst noch so alles im RaumZeitLabor machen kann und der eine oder die andere fand sogar Angebote für sich selbst so ansprechend. So wird es wohl auch mit einigen der Eltern zu einem Wiedersehen kommen.

agenda04 agenda03

Nach etwa der Hälfte der Zeit konnten die Robotik-Neulinge schon erste fast komplette Bewegungsabläufe präsentieren. Weil das ganze Programmieren, Diskutieren und Ausprobieren anstrengend ist, hatten sich die zwölf  und natürlich auch die Eltern eine gemeinsame Pause verdient. Dazu gab es ein kleines gesundes Buffet mit Obst, Gemüse und Getränken an dem sich alle stärken konnten.

agenda10 agenda09 agenda08

Nach der Pause wurden dann die Teams gemischt, so dass auch wirklich dem Nachhaltigkeitsgedanken des Agenda Diploms Rechnung getragen wurde, indem die Acht- bis Zwölfjährigen so nicht nur den Umgang mit zukunftsweisenden Themen wie Robotik, sondern auch wichtige sogenannte Softskills wie Teamfähigkeit lernen konnten.

agenda13 agenda12 agenda02

Am Ende der Veranstaltung erhielten die Teilnehmer noch eine eigens im Kartendrucker angefertigte Teilnehmerkarte mit Chip und Magnetstreifen zum Andenken an das Agenda Diplom.

agenda11

Wir sind sicher, dass wir einige der Kinder, aber auch manche Eltern in nächster Zeit wieder im RaumZeitLabor begrüßen dürfen. Darauf freuen wir uns ebenso wie auf die nächsten Teilnehmer der Veranstaltungen am 12. Juli (augebucht), 15. August und 20. September.

by zwetschgo at 13. May 2014 12:49:14

06. May 2014

RaumZeitLabor

Lötworkshop mit Mitch Altman

Mitch Altman (siehe hier, hier oder hier) wird am

Freitag, 16.5. von 15:00 bis ca 20:00 (siehe RZL Kalender)

einen kostenlosen Lötworkshop abhalten. Verschiedene LötKits sind vorhanden (siehe Liste). Auch blutige Lötanfänger sind herzlich willkommen!

Bitte meldet euch hier über die Kommentare an, da wir nur ca 10 Lötplätze bereithalten können. Wenn sich unerwartet viele Leute anmelden, werden wir sicher auch Lötkolbensharing machen können ;o)

Kommt zahlreich!

Wer es zu diesem Termin nicht schafft, kann sich auch auf der restlichen DE+UK Tour von Mitch umschauen. Vielleicht ist ja ein passender Termin dabei.
z.B. fährt Mitch nach dem Termin bei uns weiter zu den Kollegen vom shack in Stuttgart.

PS: Der Workshop wird in Englisch gehalten werden.

Noisebridge_Soldering_Workshop

by TabascoEye at 06. May 2014 21:05:43

Mero’s Blog

Python-fnord of the day

This is an argument of believe, but I think this is highly irregular and unexpected behaviour of python:

a = [1, 2, 3, 4]
b = a
a = a + [5]
print(b)
a = [1, 2, 3, 4]
b = a
a += [5]
print(b)

Output:

[1, 2, 3, 4]
[1, 2, 3, 4, 5]

Call me crazy, but in my world, x += y should behave exactly the same as x = x + y and this is another example, why operator overloading can be abused in absolutely horrible ways.

Never mind, that there is actually python teaching material out there that teaches wrong things. That is, there are actually people out there who think they know python well enough to teach it, but don't know this. Though credit where credit is due, the official documentation mentions this behaviour.

06. May 2014 01:07:28

04. May 2014

Atsutane's blog

Bugs

tl;dr: Dieser Eintrag bietet nichts wirklich lehrreiches, sondern ausschließlich meine persönliche Meinung zu Beobachtungen im Umgang mit Fehlern bei der Entwicklung von Software. Für Studenten: Die Modelle beschreibe ich hier so, wie ich sie aus der Praxis kenne. Ich habe im WS 12/13 eine Vorlesung zu der Thematik besucht und mein damaliger Professor schüttelt sicherlich den Kopf, denn dies ist nicht die akademische Art, die er uns lehrte.

Mit Heartbleed hat es ein Bug geschafft, die Aufmerksamkeit der Gesellschaft auf die Entwicklung von Software zu lenken. Im Radio wird darüber gesprochen und in den meisten Tageszeitungen steht, man sollte umgehend seine Passwörter ändern, dass es sinnvoller ist zu warten, bis seitens der Administration eine Aussage existiert, ob eine betroffene OpenSSL Version/Variante eingesetzt und ersetzt wurde, wird hier völlig unter den Tisch fallen gelassen.

Heartbleed ist ein Fehler in OpenSource Software, eines der weitverbreiteten Pro-OpenSource Argumente ist, dass jeder in den Source schauen kann. Vielen Leuten sind über die Folgen des Fehlers verärgert und dementsprechend stark wird dieses Argument nun dafür genutzt wie schlecht doch OS ist und das dies nicht geschehen wäre, wäre die Software von einem großen Unternehmen geschrieben worden. Verweist man dann auf Microsofts derzeitigen Zero Day Exploit bei Internet Explorer Version 6 aufwärts kassiert man einen bösen Blick.

Der Umstand, dass auch dieser Fehler in einer kommerziellen Software weitreichende Konsequenzen hat und Microsoft sogar für das erst vor kurzem aus der Wartung entfernte Windows XP nochmals ein Update veröffentlicht, zeigt aber: Wenn nur wenige Leute darauf schauen passieren Fehler und bleiben lange bestehen. Ob Software nun OpenSource Software ist oder das kommerzielle Produkt eines Unternehmens, dass den Kunden keinen Einblick in den Code gewährt macht keinen Unterschied, wenn sich nur wenige Personen die Quelltexte anschauen. Bei OpenSource hofft man einfach, dass es genug andere machen und bei kommerzieller Software eines Konzerns mit mehreren tausend Mitarbeitern sind es vielleicht auch nur fünf Entwickler, welche für das Produkt zuständig sind.

Zur Vermeidung von Fehlern in Software gibt es verschiedene Möglichkeiten, welche sich auch kombinieren lassen. Zum Beispiel testgetriebene Entwicklung, es werden zuerst die Tests geschrieben, anschließend Code der diese Tests besteht. Diese Art von Tests prüft aber letzten Endes auch nur, ob die Ergebnisse der Software die erwarteten sind. Je fein granulierter die Tests sind lässt sich so natürlich einiges an Fehlern vermeiden und aufspüren, es wird aber hautsächlich geprüft, ob die tatsächlichen Ergebnisse den erwarteten entsprechen. Wird hier vergessen einen fehlerhaften Use-Case zu prüfen kann es dennoch zu Fehlern kommen. Genau solch eine Verifikation ist ja das Problem des Heartbleed Bugs, es wurde nicht geprüft, ob die Parameter zusammenpassen.

Eine weitere technische Möglichkeit ist die Statische Code Analyse mittels entsprechender Software, diese klopft den Code nach gewissen Mustern ab und findet so zum Beispiel Speicherlecks, wenn Speicher allokiert, nur in der Funktion verwendet und nicht wieder frei gegeben wird.

Und dann eben auch das im Bereich der OpenSource Software weit verbreitete Modell: manuelle Code Reviews von Patches. Prinzipiell ist dies eigentlich auch eine statische Code Analyse, nur wird hier nicht immer wieder der gesamte Code betrachtet, sondern nur die vorgenommenen Änderungen. Dies geschieht durch eine oder mehrere Personen und erhöht dadurch die Chance, dass Fehler dadurch vermieden werden, dass die prüfende Person nicht den Code geschrieben hat und ihn daher anders liest. OpenSSL nutzt dieses Verfahren und auch der Linux Kernel wird so entwickelt, bei Unternehmen ist dies abhängig von Richtlinien des Unternehmens und der Abteilungen.

Das Pair Programming Modell ist ähnlich der Code Reviews, hier arbeiten zwei Entwickler zusammen, während ein Entwickler den Code schreibt schaut der andere mit auf den Schirm und weißt auf Fehler/Möglichkeiten zur Verbesserung hin. Klingt eigentlich ganz gut und lässt sich mitunter auch durchführen, nur wird dies in den meisten Unternehmen wahrscheinlich eher als eine Bremse bei der Produktion gesehen und im OpenSource Umfeld… Ich bezweifle einfach mal, dass wenn jemand aus Kanada den Bildschirm shared, um die Uhrzeit jemand aus Holland bei der Entwicklung zuschauen möchte.

Es gibt noch andere Möglichkeiten zur Vermeidung von Fehlern, aber Fehler passieren. Wenn ein Programm selbst fehlerfreien Code hat, gibt es immer noch viele Faktoren, die zu Fehlern führen können. Optimierungen durch Compiler, Updates von Betriebssystemen oder Fehler bei der Hardware. Es ist vor allem wichtig, wie auf Fehler reagiert wird. AVM hat Anfang des Jahres, umgehend für viele Modelle ihrer Router, auch jener welche seit Jahren nichtmehr verkauft werden Firmware Updates entwickelt und bereitgestellt. Von vielen anderen Herstellern liest man seit Monaten von offenen Ports und Netgear hat ein Problem ja auch nur versteckt. Bei Videospielen sieht man ähnliches, kleine Entwicklerstudios patchen ihre Spiele regelmäßig und versuchen Fehler zu vermeiden, bei großen Studios und Publishern kommt unfertige Software auf den Markt, wird teuer verkauft und bis auf das Marketing ist dann alles irrelevant, der Nachfolger kommt ja im nächsten Jahr.

04. May 2014 13:36:16

29. April 2014

RaumZeitLabor

Agenda Diplom 2014 – Es geht los!

agenda

Nach den tollen Erfahrungen beim letztjährigen Agenda Diplom haben wir uns entschlossen auch dieses Jahr wieder teilzunehmen.

Diesmal geht es um Robotik.

Lego kennt jeder, aber was ist wenn die Legosteine laufen lernen?
Das erfährt man bei unserem Workshop

Wir erwecken Lego-Roboter zum Leben – Deine ersten Schritte mit LEGO Mindstorms EV3 Robotern!

Wir haben ein kurzes Video gedreht in dem man sehen kann wie viel Spaß das macht.

Die Termine für unsere Veranstaltungen:

  • Samstag, 10.Mai 2014, 15 -18 Uhr
  • Samstag, 12. Juli 2014, 14 -17 Uhr
  • Freitag, 15. August 2014, 16-19 Uhr
  • Samstag, 20. September 2014, 13-16 Uhr

Obwohl das Programm noch gar nicht offiziell erschienen ist, sondern zunächst nur in der PDF Version auf der Seite der Stadt Mannheim einzusehen ist, haben wir schon einige Anmeldungen. Wir sind aber zuversichtlich jedem interessierten Kind einen Platz anbieten zu können, bei jedem Termin sind 12 teilnehmende Kinder vorgesehen.

Das Programm des Agenda Diploms erscheint in der gedruckten Version am 5. Mai, die PDF Version kann man hier einsehen.

Anmeldungen nehmen wir unter agenda@raumzeitlabor.de entgegen.

Wir freuen uns auf spannende und unterhaltsame Workshops.

by zwetschgo at 29. April 2014 09:22:58

10. April 2014

Mero’s Blog

Heartbleed: New certificates

Due to the Heartbleed vulnerability I had to recreate all TLS-keys of my server. Since CACert appears to be mostly dead (or dying at least), I am currently on the lookout for a new CA. In the meantime I switched to self-signed certificates for all my services.

The new fingerprints are:

Service SHA1-Fingerprint
merovius.de 8C:85:B1:9E:37:92:FE:C9:71:F6:0E:C6:9B:25:9C:CD:30:2B:D5:35
blog.merovius.de 1B:DB:45:11:F3:EE:66:8D:3B:DF:63:B9:7C:D9:FC:26:A4:D1:E1:B8
git.merovius.de 65:51:16:25:1A:9E:50:B2:F7:D7:8A:2B:77:DE:DE:0C:02:3C:6C:ED
smtp (mail.merovius.de) 1F:E5:3F:9D:EE:B4:47:AE:2E:02:D8:2C:1E:2A:6C:FC:D6:62:99:F4
jabber (merovius.de) 15:64:29:49:82:0E:8B:76:47:1A:19:5B:98:6F:E4:56:24:D9:69:07

This is of course useless in the general case, but if you already trust my gpg-key, you can use

curl http://blog.merovius.de/2014/04/10/heartbleed-new-certificates.html | gpg

to get this post signed and verified.

10. April 2014 21:28:25

08. April 2014

RaumZeitLabor

BÄM!!!!! Subbahelden-Party

Holy Hacklaceshitstorm, Batman!

Bam! Zap! Pow!

Am 03.05.2014 trifft sich die >>Justice League of Boveristraße<< ab 19 Uhr in
der RZL-Cave! Let’s kick some ass!

Wir bitten euch, eure Capes davor nochmal alle in die Reinigung zu bringen,
die Augenbinden auf Mottenfraß zu überprüfen und eure Laserkanonen,
Schwerter und Schilde auf den neusten Stand zu bringen!

Falls eure Kostüme über die lange Zeit zu klein geworden sind, ist das
natürlich auch kein Problem. Jeder, der ohne passendes Outfit mit uns die
Mächte des Bösen bekämpfen will, wird von uns verkleidet und geschminkt*!

Angemessene Snacks, wie Pizza, Spinat, Spider-Ham und HotDogs werden
natürlich davor besorgt! Es wäre sehr schön, wenn ihr bis zum 01.05.2014 im
supergeheimen Blog Bescheid gebt, ob und mit wie vielen Sidekicks ihr in
eurem Heromobil anreist! Diejenigen von euch, die übermenschliche
Fähigkeiten bei der Küchenarbeit besitzen, dürfen natürlich gerne noch
Knabbersachen mitbringen!

Möge die Macht mit euch sein!

Superheldeneinladung3

* Angemessene Verkleidung ist notwendige Vorraussetzung für die
Teilnahme an der Party, Widerstand ist zwecklos, zu Risiken und
Nebenwirkungen fragen Sie Ministerium für Landwirtschaft und Superheldentum.

by Alexander Brock at 08. April 2014 19:20:58

30. March 2014

RaumZeitLabor

A Song of Cold and Hot Dishes — Feast of Thrones

A Song of Cold and Hot Dishes — Feast of Thrones

Wir werden am Montag, den 7. April, die erste Folge der vierten
Staffel mit einem opulenten Sechs-Gänge-Menü feiern.
Auf euch warten folgende Gerichte aus den Büchern:

  1. Fingerfish/Spinach-filled pastry
  2. Leek Soup
  3. Beef and Bacon Pie
  4. Feldsalat mit Wildschinken
  5. Veal with Peppersauce and Royal Peas
  6. Whitepot | Rice Pudding

Dazu werden authentische, flüssige Erfrischungen gereicht.

Das Festmahl beginnt um 19:30 Uhr.
Bitte meldet euch bis Freitag in den Kommentaren an, damit wir die Anzahl der
Portionen und den Unkostenbeitrag planen können.
don / mxf

by don at 30. March 2014 19:00:32

19. March 2014

ociru.net

runwhen: undefined reference to scan_uint

You’re compiling runwhen with a recent version of skalibs? You may encounter the following error:

1
2
3
4
5
6
7
Making compile/host/rw-match
./compile/host/rw-match.o: In function `main':
rw-match.c:(.text.startup+0x13e): undefined reference to `scan_uint'
collect2: error: ld returned 1 exit status

The following files were not made successfully:
command/rw-match

With skalibs 1.4.2, runwhen won’t compile. The solution is pretty simple, but hard to find if you’re not reading a couple of mailing lists. scan_uint has been refactored to uint_scan in the recent release of skalibs. Just replace scan_uint to uint_scan in rw-match.c and everything compiles nicely.

Thanks a lot to the guys from uberspace.de for pointing me to the solution.

19. March 2014 21:14:00

15. March 2014

sECuREs Webseite

cgit

cgit

cgit ist ein schnelles und gut-aussehendes Webinterface für git, welches in C geschrieben ist. Im Vergleich zu gitweb, trac oder anderen Interfaces ist es mindestens doppelt so schnell und (meiner Meinung nach) um Längen komfortabler.

by Michael Stapelberg at 15. March 2014 18:14:55

07. March 2014

RaumZeitLabor

Ludum Dare 29 im RaumZeitLabor

Am Wochenende vom 25. – 28. April 2014 findet zum 29. Mal der internationale Gamejam “ludum dare” statt. Um 2 Uhr in der Nacht von Freitag auf Samstag fällt der Startschuss, alleine in 48 oder als Team in 72 Stunden ein Spiel zu einem vorgegebenen Thema zu programmieren.

Wer keine Lust hat, in Einsamkeit zu programmieren oder schon immer mal jemandem beim Spiele programmieren zuschauen wollte, ist eingeladen, im RaumZeitLabor vorbeizukommen.

by silsha at 07. March 2014 23:38:33

01. March 2014

RaumZeitLabor

Das RaumZeitLabor trauert

Das RaumZeitLabor trauert.

Wir bedanken uns für euer Mitgefühl. Die Todesanzeige zum Download gibt es hier: Hacklace Todesanzeige

by fnord at 01. March 2014 22:39:38

xeens Blog

Power it off harder

Magic Hardware Fix Howto:

  • power off device
  • remove battery
  • press power button multiple times. Be creative and create a button press symphony worthy of your hardware.
  • reboot and hope for the best.

Background Story you don’t actually care about

I’ve encountered two situations where this helped, where a reboot or even removing the battery and power cable were not enough. Please share this hint because it is not something generally shared among nerds, or only as a joke reference to The IT Crowd.

One was a laptop which came into contact with the river Rhine and didn’t boot properly anymore (or not at all, I can’t remember exactly). The other was my laptop’s Ethernet card which happily created GBit/s links, but did not allow any packets to go through.

Considering I debugged the latter problem for at least three hours thinking I made a configuration error, I should probably try this sooner in the future.

I got the tip originally from Lenovo support, but I do not know how it actually works. My best guess is that there’s some residual charge in the capacitors which puts the hardware in an invalid state. If you have any insight here, please drop me a mail at stefan-blog at yrden.

01. March 2014 17:03:37

28. February 2014

Moredreads Blog

Posts Are Now Signed

My posts on this site are now signed. You can find a gpg-block in the source code of the page. Pass it to gpg, and you get the markdown used for generating the site and check the signiture, if you have my GPG key installed.

Thanks to Merovius for the neat jekyll plugin achieving this!

28. February 2014 23:15:00

19. February 2014

Mero’s Blog

go stacktraces

Let's say you write a library in go and want an easy way to get debugging information from your users. Sure, you return errors from everything, but it is sometimes hard to pinpoint where a particular error occured and what caused it. If your package panics, that will give you a stacktrace, but as you probably know you shouldn't panic in case of an error, but just gracefull recover and return the error to your caller.

I recently discovered a pattern which I am quite happy with (for now). You can include a stacktrace when returning an error. If you disable this behaviour by default you should have as good as no impact for normal users, while making it much easier to debug problems. Neat.

package awesomelib

import (
    "os"
    "runtime"
)

type tracedError struct {
    err   error
    trace string
}

var (
    stacktrace bool
    traceSize = 16*1024
)

func init() {
    if os.Getenv("AWESOMELIB_ENABLE_STACKTRACE") == "true" {
        stacktrace = true
    }
}

func wrapErr(err error) error {
    // If stacktraces are disabled, we return the error as is
    if !stacktrace {
        return err
    }

    // This is a convenience, so that we can just throw a wrapErr at every
    // point we return an error and don't get layered useless wrappers
    if Err, ok := err.(*tracedError); ok {
        return Err
    }

    buf := make([]byte, traceSize)
    n := runtime.Stack(buf, false)
    return &tracedError{ err: err, trace: string(buf[:n]) }
}

func (err *tracedError) Error() string {
    return fmt.Sprintf("%v\n%s", err.err, err.trace)
}

func DoFancyStuff(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return wrapErr(err)
    }
    // fancy stuff
}

19. February 2014 02:17:59