Entries tagged as programming
Related tags
android code computer google gui jabber java linux&unix misc mobile opensource presentation screenshot sdk shortys software video web webdesign xml bad world blog blogging browser captcha changes dns firefox fun hardware html life lighttpd media murphy networking politics privacy s9y security server spam stuff tail -f /var/log/life tv webwide zeitgeist contentmanagement free rss ruby tool wordpress javascript feedreader markup scala swing windows xslt cheatsheet comic css encryption howto im mail newsbeuter picture podcast psi regular expression subnetting test truecrypt perl conference dslr nikon photography coffee science forum unb 1Da es aktuell aufgrund von Zeitmangel relativ still auf diesem Blog ist und ich aktuell den meisten Content auf Twitter und bei RadioTux produziere, wollte ich auch an dieser Stelle mal ein Lebenszeichen von mir geben und die Slides meiner letzten Präsentation über die Programmiersprache Scala veröffentlichen.
Die Präsentation gibt es hier als PDF zum Download.
Abschließend habe ich noch ein Beispielprogramm erstellt, das den Einsatz von Scala Traits als polymorphe Typen beschreibt:
Vor kurzem hatte ich das Bedürfnis Bilder automatisiert, mit Hilfe eines Ruby-Scripts, zu verkleinern. Dieses Script sollte zudem ohne Änderungen sowohl auf Linux als auch auf Windows lauffähig sein.
Fuer diese Aufgabe ist Imagemagick natürlich ein super Werkzeug, da man es auch als Bibliothek von Ruby aus nutzen kann und auch für Windows verfuegbar ist. Unter Windows ist hierfür eine Installation von Ruby, sowie die Installation von Imagemagick und dem passenden RMagick Ruby-Gem notwendig. Unter Linux reicht es Imagamagick und Ruby mit dem Paketmanager seiner Wahl zu installieren und mittels "gem install rmagick" das Gem zu installieren.
Der eigentliche Code gestaltet sich relativ simpel. Prinzipiell lässt sich ein Bild mit wenigen Anweisungen verkleinern:
#!/usr/bin/env ruby
require 'rubygems'
require 'RMagick'
@debug = true
def resize_image(file)
puts "let's resize #{file} ..." if @debug
img = Magick::Image::read(file).first
img.resize_to_fit(1024, 1024)
img.write(file)
puts "resizing of #{file} successful" if @debug
end
Die Methode resize_to_fit() sorgt hier für das Verkleinern auf bestimmte Maximalwerte in Länge und Breite. Weiteres erfährt man aus der Doku
.Medianight
Morgen, am Donnerstag den 02.07.2009 wird an meiner Hochschule wieder die Medianight stattfinden. Hier werden die Studenten ihre Projekte des letzten Semesters praesentieren. Ich werde dort unter anderem mit meinem eigenen Projekt am Start sein.
YAXIM
Wie schon zuvor gesagt, werde ich zusammen mit Chris unser Semesterprojekt, das den Namen YAXIM traegt, vorstellen. YAXIM steht fuer "Yet Another XMPP Instant Messenger" und ist ein Jabberclient fuer die Android-Plattform. Als kleinen Vorgeschmack folgen hier noch unsere Folien und das Video der heutigen Praesentation:
Wie bei manchen anderen Kleinigkeiten haben sich bei mir ein paar der Tools aus dem Android-SDK geweigert auf meinem 64Bit Arch Linux zu starten. Anscheinend fehlten ein paar Bibliotheken. Ich versuche hier mal zusammenfassend zu beschreiben, wie ich es zum laufen bekommen habe.
SDK installieren
Da das PKGBUILD aus dem User-Repository zum einen keine Abhaengigkeiten enthaellt und zum anderen nicht aktuell ist, habe ich mich dazu entschlossen eine modifizierte Version zu verwenden:
PKGBUILD
pkgname=android-sdk
pkgver=1.5_r2
pkgrel=1
pkgdesc="Google Android SDK"
arch=('i686' 'x86_64')
url="http://code.google.com/android/"
license=('custom')
if [ "$CARCH" = "x86_64" ]; then
depends=('jre' 'lib32-libstdc++5' 'lib32-libx11' 'lib32-ncurses' 'lib32-zlib' 'lib32-sdl' 'lib32-libxext' 'swt')
else
depends=('jre')
fi
source=(http://dl.google.com/android/android-sdk-linux_x86-$pkgver.zip \
android.sh)
md5sums=('1d3c3d099e95a31c43a7b3e6ae307ed3' 'e7f23c39d02a3a280c746f7398bf5114')
build() {
mkdir -p $pkgdir/opt && \
mkdir -p $pkgdir/etc/profile.d && \
mv $srcdir/android-sdk-linux_x86-$pkgver $pkgdir/opt/android-sdk && \
cp $srcdir/android.sh $pkgdir/etc/profile.d && \
rm $pkgdir/opt/android-sdk/tools/lib/libswt* && \
cp /usr/lib/libswt-* $pkgdir/opt/android-sdk/tools/lib && \
cp /usr/share/java/swt.jar $pkgdir/opt/android-sdk/tools/lib && \
cd $pkgdir/opt/android-sdk && \
find -type d -exec chmod 755 \{\} \; && \
find -exec chmod +r \{\} \; && \
chmod +x $startdir/pkg/etc/profile.d/android.sh
}
Wie man sieht, werden die *swt*-Komponenten des SDK durch native 64Bit Versionen ersetzt. Darum ist es auch notwendig zuvor das SWT-Paket zu installieren.
android.sh
#!/bin/sh
export PATH=$PATH:/opt/android-sdk/tools
Installation
Das Erstellen und Installieren des Pakets kann nun wie gewohnt mit makepkg vorgenommen werden. Mit diesem Setup sollten dann auch die Tools fuer Eclipse wieder wie gewohnt laufen.
Wie ich bereits gestern versprochen hatte, bekommt ihr nun hier die Slides meiner Praesentation ueber Design Patterns in Ruby:
Hier gibt es das Ganze auch noch als PDF. Den SourceCode findet man hier
Da ich gerade an einem Projekt arbeite, dass XMPP auf Java verwendet, hab ich mir zu Testzwecken eine Klasse gebaut, die Smack verwendet und ein paar Moeglichkeiten der API nutzt. Es ist unter anderem moeglich sich zu verbinden, das Roster auszulesen und empfangene Nachrichten anzuzeigen. Da mir bei der offiziellen Dokumentation Beispiele gefehlt haben, die man auf einen Rutsch kopieren und bearbeiten kann, moechte ich hier ein wirklich lauffaehiges Beispiel veroeffentlichen. Ich hoffe, damit kann jemand was anfangen:
import java.util.Collection;
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.RosterEntry;
import org.jivesoftware.smack.RosterListener;
import org.jivesoftware.smack.SASLAuthentication;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.filter.PacketTypeFilter;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
public class SmackTester {
private XMPPConnection conn;
private String username;
private String password;
private String server;
public SmackTester() {
// debug option
XMPPConnection.DEBUG_ENABLED = false;
username = "einuser";
password = "einpasswort!";
server = "jabber.foo.bar";
makeConn();
doConnect();
makeRoster();
chatAction();
// wait ... (I know that's pretty ugly)
while (conn.isConnected()) {
try {
Thread.sleep(Long.MAX_VALUE);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// nothing interesting here
public static void main(String[] args) {
new SmackTester();
}
private void doConnect() {
// let's connect
try {
conn.connect();
conn.login(username, password, "someRessource");
} catch (XMPPException e) {
System.err.println("Login failed!");
e.printStackTrace();
System.exit(1);
}
System.out.println("Login succesful!");
}
private void makeConn() {
ConnectionConfiguration config = new ConnectionConfiguration(server,
5222);
// pass some connection options
config.setSASLAuthenticationEnabled(true);
SASLAuthentication.supportSASLMechanism("PLAIN", 0);
conn = new XMPPConnection(config);
}
private Roster makeRoster() {
Roster roster = conn.getRoster();
Collection<RosterEntry> entries = roster.getEntries();
// print out all entries in roster
System.out.println("---------- entries in roster -----------");
for (RosterEntry entry : entries) {
System.out.println(entry);
}
System.out.println("---------- entries in roster -----------");
// react to changes in roster
roster.addRosterListener(new RosterListener() {
// called methods ...
public void entriesDeleted(Collection<String> addresses) {
// do stuff
}
public void entriesUpdated(Collection<String> addresses) {
// do stuff
}
public void presenceChanged(Presence presence) {
System.out.println("Presence changed: " + presence.getFrom()
+ " " + presence);
}
public void entriesAdded(Collection<String> arg0) {
// do stuff
}
});
return roster;
}
private void chatAction() {
PacketTypeFilter filter = new PacketTypeFilter(Message.class);
PacketListener myListener = new PacketListener() {
public void processPacket(Packet arg0) {
if (arg0 instanceof Message) {
Message msg = (Message) arg0;
System.out.println("Message: " + msg.getFrom() + " "
+ msg.getBody());
}
}
};
// Register the listener.
conn.addPacketListener(myListener, filter);
}
private void doDisconnect() {
conn.disconnect();
System.out.println("Disconnected");
}
}
Ich sitze hier gerade in einer Hacksession bei Chris und versuche einer Preference-Activity beizubringen, dass Passwoerter in einer EditTextPreference maskiert werden. Nach etwas rumsuchen, bin ich auf die Loesung gestossen. Hier ein kleiner Prototyp:
<EditTextPreference
android:key="password"
android:title="Ich bin ein Passwortfeld"
android:summary="Hier kannst du dein Passwort eingeben"
android:dialogTitle="Bitte Passwort eingeben!"
android:singleLine="true"
android:password="true"
/>
Ich frage mich allerdings, warum man in der Dokumentation davon nichts findet ...
Wer ab und zu ruby programmiert, wird wahrscheinlich auch gefallen an irb, der ruby-Shell, gefunden haben. Bisher hat mich daran die Tatsache gestoert, dass sie per Default keine TAB-Vervollstaendigung mitbringt. Marc hat mich per Twitter auf einen Eintrag in seinem Blog hingewiesen, der das aendert:
[root@burgr:~]# gem install wirble
Successfully installed wirble-0.1.2
1 gem installed
Installing ri documentation for wirble-0.1.2...
Installing RDoc documentation for wirble-0.1.2...
Speichert man nun folgende Anweisungen in der Datei ~/.irbrc, bekommt man eine funktionierende Autovervollstaendigung und schoenes Syntax-Highlighting.
require 'rubygems'
require 'wirble'
Wirble.init
Wirble.colorize
Das Modul scheint Funktionen der darunter liegenden Commandshell zu nutzen, denn so Sachen wie zum Beispiel Strg+R fuer inkrementelle Suche funktionieren nun ebenfalls.
Ich bin gerade auf ein sehr interessantes Projekt namens ZML gestossen:
Basically, ZML is a markup language with a C-style syntax and lots of syntactic sugar. Furthermore the ZML toolchain provides a ZML to XML compiler, which means that ZML is a convinient way of writing XML. So you could regard it as an alternativ to a feature rich XML editor.
But ZML is more. It is also a technique of code generation, thus an alternativ to Model Driven Architecture. These two aspects fit together when you know that ZML code generation is done with XSLT. Using the ZML syntax instead of the XML syntax for XSLT stylesheets makes it very easy to write a code generation tool whenever approriate. No BNF, flex and bison, no theoretical knowledge about gramar and parser classes. Just some XML, XSLT and XPATH, denoted in a convinent way.
Das hoert sich nach einem interessanten Weg an um XML zu schreiben ohne sich mit den "> <" Zeichen herum plagen zu muessen.
Es scheint ja mittlerweile Volkssport zu sein, diverse moegliche und unmoegliche Sachen in JavaScript zu implementieren. Trotzdem muss ich zugeben, dass mich diese 3D-Engine in Javascript wirklich beeindruckt.
[via]
Bei vielen Diensten wie z.B. Twitter werden mittlerweile statt normalen URLs verkuerzte abgeschickt. Sollte man mal auf die Idee kommen diese wieder in Orginalform haben zu wollen, koennte man dazu fuer jeden der bekannten Dienste Methoden implementieren. Oder man benutzt die API des Dienstes longurl.com. Die Software dahinter wurde uebrigens unter der AGPL lizensiert und den SourceCode kann man hier ankucken.
Ich habe natuerlich gleich die Klasse fuer bit.ly erweitert:
#!/usr/bin/env ruby
# client class for url shortening service bit.ly and url expandig service longurl.com
require 'rubygems'
require 'net/http'
require 'uri'
require 'json'
class ShortURL
def self.shortURL(url)
api_url = "http://bit.ly/api"
res = Net::HTTP.post_form(URI.parse(api_url),{'url'=> url})
return res.body
end
def self.expandURL(url)
api_url = "http://api.longurl.org/v1/expand?url=#{url}&format=json"
res = Net::HTTP.get(URI.parse(api_url))
data = JSON.parse(res)
# if expanding url failed
if data.has_key? 'messages'
return url
end
return data["long_url"]
end
end
Somit lassen sich mit der Methode ShortURL.expandURL(uri) URLs auch verlaengern.
Zusaetzlich gibt es fuer diesen Dienst noch eine Firefox Erweiterung und ein Greasemonkey Script um die langen URLs in Tooltips darzustellen.
Vor einiger Zeit habe ich ein Tool gesucht um Newsfeeds aus einer OPML-Datei auf Erreichbarkeit zu ueberpruefen. Nachdem ich keines gefunden hatte, habe ich mir selbst eines geschrieben.
Das kleine Tool wurde nun nochmals ein klein wenig ueberarbeitet. Hier mal die groebsten Aenderungen:
- Support von Threads
- Abfangen nicht konformer HTTP-Antworten
- Abfangen von "connection refused"-Fehlern
Alleine die Verwendung von Threads bringt einen erheblichen Performancegewinn. Als Beispiel dient meine Feedliste mit 179 Feeds. Hier ist das Ergebnis der Version ohne Threads:
time ./feedchecker.rb /tmp/rss.opml
./feedchecker.rb /tmp/rss.opml 2.70s user 0.88s system 1% cpu 4:05.40 total
Und hier mal die Version mit Threads:
time ./feedchecker_thread.rb /tmp/rss.opml
./feedchecker_thread.rb /tmp/rss.opml 1.51s user 0.35s system 4% cpu 42.661 total
Das Script gibt es hier zum download. Feedback ist wie immer willkommen.
Ich arbeite gerade an einem kleinen Tool, fuer das ich den URL-Kuerzungsdienst bit.ly ansprechen wollte. Daher habe ich mir eine Ruby-Klasse dafuer geschrieben, die die RESTfull-API anspricht:
#!/usr/bin/env ruby
# client class for url shortening service bit.ly
require 'net/http'
require 'uri'
class Bitly
def self.shortURL(surl)
api_url = "http://bit.ly/api"
res = Net::HTTP.post_form(URI.parse(api_url),{'url'=> surl})
return res.body
end
end
# Possible usage
puts Bitly.shortURL("http://blog.roothausen.de")
Das Ergebnis schaut so aus:
./bitlyapi.rb http://bit.ly/2BTVbK
Ich bin mal gespannt, wie dieser Kommentar aufgenommen wird.
Security people are often the black-and-white kind of people that I can't stand. I think the OpenBSD crowd is a bunch of masturbating monkeys, in that they make such a big deal about concentrating on security to the point where they pretty much admit that nothing else matters to them.
Ich werde das nicht kommentieren. ![]()
Ich habe gerade einen wunderbaren Vortrag ueber Softwareintegration gefunden, den ich euch nicht vorenthalten will.
Quicksearch
Kategorien
Links
Tags
del.icio.us
- Appcelerator Developer Center - Documentation
- Coderspiel — Rewiring Android for type-safe layout resources
- pkrumins's stackvm at master - GitHub
- Netty - the Java NIO Client Server Socket Framework - JBoss Community
- Learn Your Motherf#@kin' Science: A Textbook for Juggalos | Cracked.com
- The C Book - Table of Contents
- andrewvc's node-streamlogger at master - GitHub
- Setting up a JavaScript Build Process – JavaScriptr
- js-build-tools - Project Hosting on Google Code
- YUI Compressor
- JsUnit
- InfoQ: Ralph Johnson, Joe Armstrong on the State of OOP
- ztellman's aleph at master - GitHub
- Clojure - home
- Mac OS X keyboard shortcuts

