Techpriester::blog()

Name that code - Online programming quiz

Mon, 16 Aug 2010 17:47:00 +0200

Created by OnePlusYou - Free Dating Sites

It’s a bit too easy, but fun anyway …

Thingler

Fri, 06 Aug 2010 16:26:33 +0200

Thingler:

A really simplified collaborative todo list written entirely in JavaScript using node.js and CouchDB.

9 Notes for Developers

Mon, 02 Aug 2010 18:50:39 +0200

fuckyeahcomputerscience:

wedothingsinc:

In any creative discipline, it’s good to have pointers that can keep you on the straight and narrow. Developing is one of these disciplines. From my experiences, I’ve put together 9 quick notes which can improve the way you code, and the way you see developing. It’s a valuable read, especially for anyone starting out or for programmers looking to refine their skills.

Read More

(submitted by floop)

How to choose your first programming language

Wed, 28 Jul 2010 20:24:00 +0200

Everyone has to start somewhere and of course that applies to programming, too. But getting started in programming puts you in front of one important question right at the start: What language should I start with?

There’s a gazillion of languages that are fitted for beginners. Some of them may prove to be your tools of choice even when you’ve gathered some experience. Others, well, won’t.

So how do most people choose their first language? Simple, they don’t. They let someone else tell them what to use. That could be their computer sience professor (which may be good or bad), their boss (probably bad) or “that friend who really knows computer stuff” (wich is almost guaranteed to be bad).

If your choice of a language is only based on one persons views, it’s not unlikely that this person will have a very subjective opinion about the “best language” for you. So I think the first thing to do is to ask more people. In times of the web, this should not be a problem. Just go to any website where programmers hang around (like stackoverflow.com) and start asking. They won’t eat you for breakfast. Most of them actually like to answer these kind of questions because it gives them the opportunity to promote their favorite tools.

Which leads you to the next problem: How can you tell wether the guy who just told you to learn “LanguageX” because it’s “the bestest of them all” is not just a fanboy of “LanguageX”? You can try the following steps, all with one single person:

Ask, why you should use LanguageX. You’ll probably get more than enough answers.
Ask, what the drawbacks of LanguageX are.
Ask, what language does the things mentioned in step 2 better.

If the guy is unable or not willing to provide satisfying answers to questions 2 and 3, he’s probably just a fanboy and you shouldn’t pay much attention to him.

Repeat this with some more people. You’ll notice that you will get very different answers from different people but that’s OK. The whole point of this is to learn what the highlights and pitfalls of all these languages are. Any modern programming language probably “works” for anything you may want to do as a beginner but it can be very disappointing to discover major drawbacks later on after you’ve become used to it.

Of course this is not guaranteed to result in THE PERFECT CHOICE™ but it may help you get started with a lot less pain and a lot more fun because it’s just awesome to discover later on that the tool, that you started out with can still do the job for you.

After having said that, I suggest, you learn Piet because it’s just super incredibly cool and perfect in every aspect with no drawbacks at all. Period. Just look at what you can do with it …

Adding .indexOf() to arrays in Internet Explorer

Wed, 28 Jul 2010 19:22:34 +0200

Most of you will already know this but hey, it doesn’t hurt to tell the tale again.

Looking up an array elements value by key is trivial:

var bar = someArray['foo'];

In actually working javascript implementations the reverse is simple, too:

'foo' == someArray.indexOf(bar); //will be true after the above code snippet

The actual API docs can be found over at Mozilla.org.

However, there is still this one JavaScript engine that is not only broken beyond repair but also lacks important features in the first place. I’m talling, of course, about our beloved Interbet Explorer.

Trying to use someArray.indexOf() in up to IE8 will result in an error message telling you that the object does not support this method.

So, let’s fix this!

if (typeof Array.prototype.indexOf !== 'function') {
    Array.prototype.indexOf = function(value) {
        for (var idx in this) {
            if (this.hasOwnProperty(idx)) {
                if (this[idx] == value) {
                    return idx;
                }
            }
        }
        return -1;
    }
}

This will check, if the engine that your script is running on already has the indexOf() method, and if not, it will simply add it to the Array prototype and by that to all present and future arrays.

Not exactly a game changer, but useful.

The Time Zone Converter

Wed, 28 Jul 2010 19:15:05 +0200

The Time Zone Converter:

onethingwell:

Does what it says on the tin.

We really should remind us of this more often...

Sun, 18 Jul 2010 02:11:31 +0200

We really should remind us of this more often …

fuckyeahcomputerscience:

2 things every programmer needs to know

(via fuckyeahcomputerscience)

Sun, 18 Jul 2010 02:09:47 +0200

(via fuckyeahcomputerscience)

rxq: Se nada der certo, viro analista de mídias sociais. [via...

Thu, 01 Jul 2010 22:35:58 +0200

rxq:

Se nada der certo, viro analista de mídias sociais.

[via http://www.oesquema.com.br/urbe ]

Harry Potter on the UNIX Shell

Sat, 19 Jun 2010 10:19:00 +0200

Harry Potter on the UNIX Shell:

Spells from Harry Potter and their corresponding Bash commands:

Accio: wget (Pulls an object to the caster.)

Alohomora: chmod +rw (Unlock a door.)

Avada Kedavra: rm -rf / (The killing curse.)

Colloportus: chmod uo-rw (Prevents a muggle from openin a door.)

Deletrius: history -c (Deletrius clears a wand’s spell history.)/li>

Episkey, Reparo: fsck (Heal minor injuries./Fixes objects.)

Gemino: cp (Makes a copy of an object.)

Homenum Revelio: who (Reveals humans near caster.)

Pack: tar (Packs up objects into a container.)

Portus: ln -s (Creates portkey.)

Prior Incantato: Ctrl+P, history 1 (Shows a ghost of the last spell casted.)

Rictusempra: touch (Causes the sensation of beeing tickled.)

PHP style date formatting in JavaScript

Sat, 12 Jun 2010 15:43:00 +0200

A lot of people probably already know PHPs date formatting system and are quite familiar with it. Using formatting strings like “Y-m-d H:i:s” makes it really easy to produce nicely formatted date strings in a way that is relatively easy to remember since you probably use the same few formatting strings all the time. In combination with the much improved DateTime class in PHP 5.3 this gives you all the tools you need to work with dates and timestamps.

JavaScript has a very powerful and comfortable Date object, too. The only thing that’s missing is an output formatting method that doesn’t involve concatenating the strings from the single outputs of the Date object together manually.

So here it is: An extension of the Date object that replicates the functionality of PHPs formatting system:

/*
 * The following call returns a closure which has some helper functions and objects in it's scope.
 * The closure is then added to the Date prototype and will be available in all Date objects as the "format" method.
 */
Date.prototype.format = (function () {
    /*
     * Helper function for padding numbers with zeros on the left side
     * @private
     * @param {Number} number The input number that is to be padded
     * @param {Number} digits The number of digits of the resulting number
     * @return {String}
     */
    var pad = function(number, digits) {
        var padding = '';
        while ((number + padding).length < digits) {
            padding += '0';
        }
        return padding + number;
    };
    var weekDaysShort = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
    var weekDaysLong  = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
    var monthsShort   = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];

    /*
     * Helper method to determine if an hour in 24h format is AM or PM
     * @param {Number} h The hour in 24h Format
     * @return {String}
     * @private
     */
    var amPm = function(h) {
        if (h<=12) {
            return 'am';
        } else {
            return 'pm';
        }
    };

    /*
     * Constructor for the replacer object that provides methods for the format placeholders
     * @param {Date} The Date object that serves a s adata source for the string replacements
     * @constructor
     */
    var Replacer = function(d) {
        this.dO = d; //makes the passed Date object available to the Replacers prototype
    };
    Replacer.prototype = {
        d: function () {return pad(this.dO.getDate(), 2);},
        D: function () {return weekDaysShort[this.dO.getDay()];},
        j: function () {return this.dO.getDate();},
        l: function () {return weekDaysLong[this.dO.getDay()];},
        N: function () {return this.dO.getDay()+1;},
        S: function () {
            var n = this.dO.getDate();
            if (n == 11 || n==12 || n==13) {
                return 'st';
            }
            n = n % 10;
            switch (n) {
                case 1: return 'st';
                        break;
                case 2: return 'nd';
                        break;
                case 3: return 'rd';
                        break;
                default: return 'th';
            }
        },
        w: function () {return this.dO.getDay();},
        m: function () {return pad(this.dO.getMonth(),2);},
        M: function () {return monthsShort[this.dO.getMonth()];},
        n: function () {return this.dO.getMonth()+1;},
        Y: function () {return this.dO.getFullYear();},
        y: function () {return this.dO.getFullYear().toString().substr(2);},
        a: function () {return amPm(this.dO.getHours());},
        A: function () {return amPm(this.dO.getHours()).toUpperCase();},
        g: function () {return this.dO.getHours() % 12;},
        G: function () {return this.dO.getHours();},
        h: function () {return pad(this.dO.getHours() % 12, 2);},
        H: function () {return pad(this.dO.getHours(),2);},
        i: function () {return pad(this.dO.getMinutes(),2);},
        s: function () {return pad(this.dO.getSeconds(),2);},
        U: function () {return this.dO.getTime();}
    };

    /*
     * Returns a closure that has all the needed private helpers in it's scope.
     */
    return function (format) {
        var returnString = '';
        var replacer = new Replacer(this);
        for (var i = 0; i < format.length; i = i + 1) {
            if (typeof replacer[format[i]] !== 'undefined') {
                returnString += replacer[format[i]]();
            } else {
                returnString += format[i];
            }
        }
        return returnString;
    };
}());

After executing this piece of code, all your Date objects will have a format() method. Even the ones that have been created earlier due to JavaScripts prototypal inheritance system.

You can call the format() method with a formatting string just like in PHP. It uses the same tokens to represent the individual fields. For a detailed explanation what every token does, please consult the PHP manual page for date().

This version here does not support all the formatting options that are available in PHP but the common ones are in there.

If you need additional formatting options, you can easily extend the formatter by adding new methods to Replacer.prototype where all the tokens for the format string are defined as functions.

"Saying “I know .” is like saying “I can drive a..."

Tue, 01 Jun 2010 20:05:00 +0200

“

Saying “I know .” is like saying “I can drive a car”.

It says nothing about wether you’re a professional race driver or if you crash at least once a year.

”

- This especially applies to languages that are easy to get into.

(via fuckyeahcomputerscience)

Wed, 26 May 2010 21:57:41 +0200

(via fuckyeahcomputerscience)

How asynchronicity gets you a nice girl

Wed, 26 May 2010 21:50:15 +0200

I just made myself some pasta. Ok, nothing spectacular so far, just pasta with plain tomato sauce. But while doing so, I thought about the way I was acting and recognized the similarity between my pasta cooking and …

… JavaScript. Yes, JavaScript.

Let me explain. What’s the “algorithm” for making pasta with tomato sauce? It’s something like this (may vary depending on your favored pasta style):

Put salt water on the stove.
While the water heats, put some oil into a frying pan.
While the oil heats, cut an onion. The water is still heating.
Fry the onion while you cut some tomatoes.
Add tomatoes to the onions.
Your water could be boiling by now, so add pasta to the water.
Let the sauce loose some water by boiling it for a while.
Then add some spices.
Take the pasta pout of the water, when it’s finished (This will probably take the most time).
Add sauce.
Eat it and Be happy.

You see, there’s a lot of stuff happening concurrently although you are doing it alone - “single threaded”, so to speak. This is very much like the asynchronous calls that are common in JavaScript and some other languages. The whole process just takes as long as its longest part, which is probably boiling the pasta.

Now image making pasta synchronously, like you would program in the more traditional way:

Put water on the stove.
Wait until it boils
Put the pasta in the water
Wait until its ready.
Cut the onion
Put oil into the pan.
Wait …
Put the onion into the hot oil.
Wait …
…

You see where this is going. There’s a lot of waiting involved. That’s time in which you could have done something useful. Like inviting a nice girl over to share the pasta with. But sadly, because you chose synchronous cooking, you’ll eat not only much later but also alone. And your pasta will most likely have gotten cold while you were so busy with idling.

Now think again about how “complicated” and “hard to grasp” asynchronous programming really is.

PS: I didn’t invite anyone over for pasta because I used the free time that I had because of asynchronous cooking to write this post ;)

Maybe I should set some different priorities …

PPS: And don’t get me started on multithreaded cooking. My kitchen is barely big enough for one person. Just like your computers RAM is just not big enough to be wasted on threads.

"Software development over the past decade was pretty much ruled by Java. I have this strange..."

Thu, 20 May 2010 21:30:54 +0200

“

Software development over the past decade was pretty much ruled by Java.

I have this strange feeling that the next one will belong to JavaScript.

”

- My cerebellum just said that …

Precise finance in JavaScript

Thu, 20 May 2010 21:03:36 +0200

JavaScript knows only one number type: signed 64Bit floating point.

That is pretty cool most of the time because you can’t run into strange type conversion issues when every number is already of the exakt same type.

However, as soon as you do financial mathematics in JS, you’ll run into pretty bad mojo. Money does not have more than two decimal fractional digits and it’s always rounded before any calculation is made. So if you throw around money values in JavaScript, it will behave incorrect in terms of currency although the math is perfectly fine.

To mitigate the dangers of this problem, you can introduce a new type of number: The Money object! It’s an object made of cash, yeah!

Ok, here’s the code:

var Money = function(amount) {
        if ('number' !== typeof amount) {
            amount = 0;
        }
        this.amount = amount;
    }
Money.prototype.valueOf = function() {
    return Math.round(this.amount * 100) / 100;
}

The valueOf() method is called every time you try to use an object like a primitive type like Number, String or Boolean. By default it returns the string “[object Object]” if you try to do that, which is not very useful. But as you see you can override this behavior by defining a new method of the same name on the constructors prototype.

Now this happens:

var m = new Money(50.42355446);
var n = new Money(30.342141);

sys.puts(m.amount + n.amount); //80.76569546
sys.puts(m+n);                 //80.76

You can implement a more sophisticated (and maybe less customer friendly) rounding algorithm, if you like. I’m not an accountant but I’m sure there are rules how money has to be rounded in different situations.

And hey, having a constructor for Money sounds pretty awesome, right?

onethingwell: ImageOptim optimizes images — so they take up...

Wed, 19 May 2010 21:31:08 +0200

onethingwell:

ImageOptim optimizes images — so they take up less disk space and load faster — by finding best compression parameters and by removing unnecessary comments and color profiles. It handles PNG, JPEG and GIF animations.

Just tried it on several hundred photos that I carry around on my phone. It does a nice and fast job.

onethingwell: Loremify is a one-click tool to copy Lorem...

Sun, 16 May 2010 01:30:29 +0200

onethingwell:

Loremify is a one-click tool to copy Lorem Ipsum. It lets you wrap in html, specify the amount of text, and copy it to your clipboard—all in one click. It runs as a Dashboard Widget in Mac OS X, and is a mere 400kb download.

Via Giles.

Works like a charm. Awesome UI idea to use the mouse position over the buttons as a measure for the wanted amount of Lorem Ipsum.

We all use random number generators all the time in our...

Sat, 15 May 2010 15:37:16 +0200

We all use random number generators all the time in our software. Mostly these generators only produce pseudo random numbers. They calculate their numbers from thing like the computers internal clock so it’s actually not random. For truly unpredictable numbers, you need a physical source of entropy.

I just wanted to illustrate the difference between synthetic random numbers and real ones. The pictures show software generated noise how it can be made with most image editing programs and a difference blending of two high ISO exposures from a digital camera which produces real physical entropy.

I think, the difference is quite obvious just by looking at them. Just keep that in mind, when you expect something to be “random” next time.

Protect your late statics!

Wed, 12 May 2010 20:29:59 +0200

In PHP 5.3 we got a great feature called “late static binding”. If you don’t know it yet, read about it here.

However, there’s a little problem that may confuse some people and that may also lead to quite unexpected behaviour, if you don’t pay attention to it. Let me demonstrate:

<?php
class Foo
{
    static public $foo = 23;
}

class Bar extends Foo
{
    public function __construct()
    {
        static::$foo = 42;
    }
}

echo 'Foo: '.Foo::$foo.PHP_EOL; // 23
echo 'Bar: '.Bar::$foo.PHP_EOL; // 23
$o1 = new Bar();
echo 'Bar: '.Bar::$foo.PHP_EOL; // 42
Bar::$foo = 5;
echo 'Foo: '.Foo::$foo.PHP_EOL; // 5 ... ouch!

As expected, The call to Bar::__construct() accesses the static member $foo in the context of Bar and not Foo. If I had used “self::” instead of “static::”, it’d have changed the value of Foo::$foo. So that’s all working fine.

The problem occurs when I change the value of Bar::$foo from the outside, which is allowed because I declared it as public. Now, since there is no late static binding for the Paamayim Nekudotayim (Yes, that’s the correct name for “::”) outside of the class it is operating on, I actually changed Foo::$foo intead of Bar::$foo. This may be bad.

To avoid this issue, just declare our static members private and unless you want this to happen, access them via public getter/setter methods that can make use of the late static binding.