Ganz viel DTrace :D

Heute war ein ziemlich voller Tag. Ich habe unter anderem meinen Vortrag über DTrace den ich schon einmal in der warpzone gegeben habe bei der Mac User Group Gütersloh gehalten. Ich hab versucht dieses doch sehr technische Thema möglichst einfach rüber zu bringen da die Folien eigentlich eher für ein sehr technophiles Publikum gedacht waren. Hoffe ihr habt trotzdem Spass daran ;)


Für alle die was auf die Ohren wollen hatte ich die Ehre eine Sendung mit Mario Heide von Pofacs zu machen. Also: die volle Dröhung DTrace :D

Quicksort in Scala

Ich weiß, ich weiß. Nicht schon wieder ein Quicksort. Dem ein oder anderen wird es sicher schon zur Nase rausquillen, aber generische Quicksort Algorithmen sind wirklich ein guter Weg um eine neue Sprachen kennenzulernen (zumindest empfinde ich das so ^^) Dieser hier ist mit ein wenig Hilfe zustande gekommen. Warum ist das ganze überhaupt wert gepostet zu werden? Erstmal ist Scala eine sehr interessante Sprache die den Versuch unternimmt FP und OOP zu vereinen (ohne dabei in das Kitchen-Sink Muster zu verfallen), des weiteren läuft sie auf der JVM was einem die Möglichkeit gibt auf den reichhaltigen Fundus an Java-Libs zurückzugreifen und die Vorzüge der JVM zu nutzen. Spannende Sprache für alle die mal was ganz anderes sehen wollen ;)

object Main {
  def qs[T <% Ordered[T]](list: List[T]): List[T] = 
    list match {
      case Nil   => Nil 
      case x::xs => {
        val (l, g) = xs partition (_ < x)
        qs(l) ++ (x::qs(g))
      }   
    }   

  def main(args: Array[String]): Unit = { 
    val a = List(5,3,2,1,7,8,9,4,6)
    println(qs(a))
  }

}

Bitbucket Repository für Codeschnipsel

Ich werde immer mal wieder nach Config-Files oder Codeschnipseln gefragt die ich dann meistens auf meinen Blog stelle. Diese sind aber dank von Blogspot schwer bis gar nicht lesbar, also habe ich sie einfach mal auf Bitbucket geschoben. Dann haben alle was davon ;)

hg clone https://raichoo@bitbucket.org/raichoo/ksh-mercurial-integration/

Viel Spass beim rumspielen. Ich hoffe ihr könnt was damit anfangen und habt vielleicht den ein oder anderen Verbesserungsvorschlag.

UPDATE: Links aktualisiert

KSH93: Mercurial Promptmode

Nach dem großartigen Blogeintrag von Steve Losh und seinem ZSH-Mercurial Prompt habe ich mir gedacht: "Ok, das geht auch mit der KSH". Ich verfolge allerdings einen etwas anderen Ansatz. Anstatt das meine Shell bei jedem Kommando selbst überprüft ob sie in einem Repository ist (zuviel Overhead meines Erachtens nach) habe ich unterschiedliche Modes definiert (ksh für "shell" und hg für "mercurial") zwischen denen ich mit mode wechseln kann.
Der Prompt färbt sich rot wenn sich der Status verändert hat und zeigt mir neben der Revisionsnummer auch noch den Namen das Branches an auf dem ich gerade bin :)

_checkrevision() {
    set -A HGOUTPUT $(hg id -n -b -t 2> /dev/null)
    if [[ ${HGOUTPUT[0]} != "" ]]
    then
        if grep '+' <(echo ${HGOUTPUT[0]}) > \
/dev/null 2> /dev/null
        then
            print ":${BOLD}${RED}${HGOUTPUT[0]}${NORM}\
@${CYAN}${HGOUTPUT[1]}${NORM}" && return
        elif grep -v 'tip' <(echo ${HGOUTPUT[*]}) > \
/dev/null 2> /dev/null
        then
            print ":${BOLD}${YELLOW}${HGOUTPUT[0]}${NORM}\
@${CYAN}${HGOUTPUT[1]}${NORM}"\
 && return
        else
            print ":${BOLD}${GREEN}${HGOUTPUT[0]}${NORM}\
@${CYAN}${HGOUTPUT[1]}${NORM}"\
 && return
        fi  
    fi  
}

mode() {
    if [[ $1 == 'ksh' ]]
    then
        export PS1='${NORM}\[${USERCOL}${USER}${NORM}\@\
${HOSTCOL}${HOSTNAME}${NORM}\:${BLUE}$(_checkdir)\
${NORM}]\:${RED}${HISTCMD}${NORM}\> '
    elif [[ $1 == 'hg' ]]
    then
        export PS1='${PURPLE}☿${NORM}$(_checkrevision)> ' 
    fi  
}

Das ist jetzt die erste Version. Mal sehen wie sich das gute Stück noch weiterentwickelt :)

UPDATE: Hab den Code noch mal um einiges verbessert.

Quicksort in Python

Und einfach nochmal weils so schön ist:

def partition(f, a): 
    l = []
    r = []
    for i in a:
        if f(i):
            l.append(i)
        else:
            r.append(i)
    return l,r 

def qs(a):
    if a == []: 
        return a
    return  qs([x for x in a[1:] if x < a[0]]) \
            + [a[0]] + \
            qs([x for x in a[1:] if x >= a[0]])

def qs2(a):
    if a == []: 
        return a
    l,g = partition(lambda x: x < a[0], a[1:])
    return qs2(l) + [a[0]] + qs2(g)

a = [4,6,3,5,1,2,7,0,9,8]

print qs(a)
print qs2(a)

Und die Ersties bei mir an der Uni beschweren sich darüber das sie funktionale Programmierung lernen müssen -_-

UPDATE: Das ganze geht noch schöner mit Python List Comprehensions

Ein Hauch von Python

Ich spiele ja in letzter Zeit sehr viel mit Ruby und Python herum. Was mir an Python besonders gefällt sind unter anderem Generatoren. Damit kann man schöne Sachen machen.

def test():
    for i in range(0,3):
        yield i

x = test()

for i in x:
    print i

Einen ähnlichen Effekt kann man unter Ruby mit Enumeratoren hinkriegen

class Test
    def each
        if block_given?
            for i in 0...3
                yield i
            end
        else
            Enumerator.new(self)
        end 
    end 
end

t = Test.new
e = t.each

for i in e
    puts i
end

Ich gebe zu das ich hier ziemlich geschummelt habe und Python Generatoren über das hinausgehen was ich hier in Ruby zeige. Aber es kann hin und wieder mal recht praktisch sein ;)

Quicksort in Ruby

Angestachelt vom Alios' kurzer Illustration von Quicksort in Haskell hab ich mir mal überlegt ob man das gleiche auch in Ruby 1.9 so schreiben kann. Man kann ;)

def qs(a)
    return a if a == []
    (qs a.drop(1).find_all{|x| x < a[0]}) \
    + [a[0]] + \
    (qs a.drop(1).find_all{|x| x >= a[0]})
end

Ich finde das ganze zeigt sehr eindrucksvoll wie mächtig moderne Sprachen sind die OOP und FP vereinen. Prinzipiell kann man das Ding auch twittern :P (darum die kurzen Namen)

UPDATE: Da konnte man noch etwas verkürzen ^^

UPDATE 2: Für alle denen 2 Array Durchläufe mit find_all zuviel sind gibts hier auch noch eine etwas nettere Version ;)

def qs(a)
    return a if a.empty?
    l, g = a.drop(1).partition{|x| x < a[0]}
    (qs l) + [a[0]] + (qs g)
end