Only 8% members of the Scientific Research Society agreed that “peer review works well as it is”. (Chubin and Hackett, 1990; p.192).

“A recent U.S. Supreme Court decision and an analysis of the peer review system substantiate complaints about this fundamental aspect of scientific research.” (Horrobin, 2001)

Horrobin concludes that peer review “is a non-validated charade whose processes generate results little better than does chance.” (Horrobin, 2001). This has been statistically proven and reported by an increasing number of journal editors.

But, “Peer Review is one of the sacred pillars of the scientific edifice” (Goodstein, 2000), it is a necessary condition in quality assurance for Scientific/Engineering publications, and “Peer Review is central to the organization of modern science…why not apply scientific [and engineering] methods to the peer review process” (Horrobin, 2001).

…

Chubin, D. R. and Hackett E. J., 1990, Peerless Science, Peer Review and U.S. Science Policy; New York, State University of New York Press.

Horrobin, D., 2001, “Something Rotten at the Core of Science?” Trends in Pharmacological Sciences, Vol. 22, No. 2, February 2001. Also at http://www.whale.to/vaccine/sci.html and http://post.queensu.ca/~forsdyke/peerrev4.htm (both pages were accessed on February 1, 2009)

Goodstein, D., 2000, “How Science Works”, U.S. Federal Judiciary Reference Manual on Evidence, pp. 66-72 (referenced in Hoorobin, 2000)

This sounds so true to me. I heard way more than one story from Ph.D. students where the professors who were supposed to review papers just forwarded this work to their slaves.

But the fact that academic peer reviews are possibly a failure should not be used to argue against the usefulness of code reviews.

As a reviewee
My first project at Google was written in Python. I had never written a single line of Python before. The feedback I got from the first few reviews helped me learn a lot about Python in a very short time. I don’t know how many times I got these “Yes, this would work but if you replace these 6 lines with that short statement it would work, too” comments.

The same is true for my second project in C++. I have written some C++ before but this was for my Diploma thesis and the code was far from professional. Again the feedback I got from my reviewers helped me learn C++ a lot faster than I would have otherwise. This project was a lot bigger than the first one so I got a few “we already have this implemented here” comments.

As a reviewer
I usually don’t pay that much attention to our coding conventions but my pet peeve is looking out for missing comments. Every time I have to think about a single line of code, this is a pretty good signal that a comment is missing.

Reviewing other people’s code makes sure that I have at least a little knowledge about the areas of our project I do not work on directly.

Conclusion
Code reviews take time and need the proper tool support. But if it is done right, they are useful and help in a couple of different areas:

• Learning a new language or about new piece of code.
• Avoiding code duplication.
• Making sure code is documented.
• Distribute the knowledge.

I stumbled over this funny site called CodeGolf.com and tried my luck on the first problem (actually it’s the sixth, but it was the last and therefore appeared first on their page – confused?) Writing a Brainfuck Interpreter:

The brainfuck language uses a simple model of a computer consisting of an array of memory cells, a movable pointer into the array, an output stream, an input stream and the program itself. The program is formed from a sequence of the below commands :

• > – Increment the pointer to point to the next cell to the right.
• < – Decrement the pointer to point to the next cell to the left.
• + – Increment the byte pointed to by the pointer.
• - – Decrement the byte pointed to by the pointer.
• [ - Jump forward to the command after the corresponding ] if the byte at the pointer is zero.
• ] – Jump back to the command after the corresponding [ if the byte at the pointer is non-zero.
• . - Output the value of the byte at the pointer.
• , - Accept one byte of input, storing its value in the byte at the pointer.

It didn't take me very long to write a running interpreter. My first version was more than a thousand characters. Even after renaming the variables and stripping all the whitespaces I still needed around 700 characters, which is huge compared to the best Ruby solution with only 142 characters.

Warning! Spoilers ahead - you might want to stop reading if you want to solve the problem, too

Brainfuck Interpreter Version 1 - a real interpreter

This was my very first idea. The algorithm is pretty obvious and nothing really fancy was done here. Two optimizations:

• aggregated the + and - operation and < and > into one when each to save space
• iterate over the input program to get the target addresses for the jump operations

But this code was still too slow. It passed the first 5 tests, but failed the rot13 performance test.

# Version 1 after a lot of rewrites

data = Array.new(30000,0)
datapointer = 0
codepointer = 0

(code,input) = STDIN.read.chomp.split '!'

# build a jump table to quickly access target address to jump to
stack = []
jmptbl = {}
(0..(code.size-1)).each {|i|
  case code[i]
    when 91: stack.push i
    when 93: m = stack.pop; jmptbl[i] = m; jmptbl[m] = i
  end
}

while codepointer < code.size do
  x = code[codepointer]
  case x
# < >
    when 60, 62: datapointer = datapointer + x - 61
# + -
    when 43, 45: data[datapointer] = (data[datapointer] - x + 44) % 256
# [
    when 91: codepointer = (data[datapointer] == 0 ? jmptbl[codepointer] : codepointer)
# ]
    when 93: codepointer = (data[datapointer] != 0 ? jmptbl[codepointer] : codepointer)
# .
    when 46: print "#{data[datapointer].chr}"
# ,
    when 44: data[datapointer] = input.slice!(0)
             exit if data[datapointer].nil?
  end
  codepointer = codepointer + 1
end

# Version 1 obfuscated
# 389 characters without this comment
d=Array.new(30000,0)
a=0
b=0
(c,k)=STDIN.read.chomp.split'!'
s=[]
j={}
(0..(c.size-1)).each{|i|
case c[i]
when 91:s.push i
when 93:m=s.pop;j[i]=m;j[m]=i
end
}
while b<c.size do
x=c[b]
case x
when 60,62:a=a+x-61
when 43,45:d[a]=(d[a]-x+44)%256
when 91:b=(d[a]==0?j[b]:b)
when 93:b=(d[a]!=0?j[b]:b)
when 46:print"#{d[a].chr}"
when 44:d[a]=k.slice!(0)
exit if d[a].nil?
end
b=b+1
end

Brainfuck Interpreter Version 2 - "optimize - don't do it"

This code contains many useless optimizations

• store the target address inside the program as the address for ] or address plus codesize for [
• store + and - as -255 and -257, so I can simply add the command to the data

But these optimizations didn't provide any significant speedup, the code was only about 10 percent faster on my machine which was still too slow to pass the performance test. And the program was even larger than my original version with 533 characters. I could perhaps squeeze out a few characters with a complicated formula for the first 6 lines of the case statement, but I didn't try this because this version was too slow anyway.

# version 2 - forget it, it sucks
data = Array.new(30000,0)
codepointer = 0
datapointer = 0

(code,input) = STDIN.read.chomp.split '!'

codesize = code.size
stack = []
opt = []
(0..(codesize-1)).each {|i|
  case code[i]
    when 60: opt << -3
    when 62: opt << -1
    when 43: opt << -255
    when 45: opt << -257
    when 44: opt << -5
    when 46: opt << -6
    when 91: stack.push opt.size; opt << 0 # just a placeholder
    when 93: m = stack.pop; opt[m] = opt.size + codesize; opt << m
  end
}
while codepointer < opt.size do
  x = opt[codepointer]
  if x < -200
    data[datapointer] = (data[datapointer] + x) % 256
  elsif x < -3
    if x == -5
      data[datapointer] = input.slice!(0)
      exit if data[datapointer].nil?
    else
      print "#{data[datapointer].chr}"
    end
  elsif x < 0
    datapointer = datapointer + x + 2
  else
    if x < codesize
      codepointer = (data[datapointer] != 0 ? x : codepointer)
    else
      codepointer = (data[datapointer] == 0 ? x % codesize : codepointer)
    end
  end
  codepointer = codepointer + 1
end

Brainfuck Interpreter Version 3 - Brainfuck to Ruby

As I realized I wasn't going to pass the performance test with my other ideas I knew I had to generate Ruby code. The tricky part was how to simulate the commands "[" and "]". I started with the "Hello World!" Brainfuck program and rewrote it step by step in Ruby until I had an idea on how to replace every character of the input language with a chunk of Ruby code.

The definitions for the methods are shown below. The whole program was slightly larger than my version 1 but it is about 3 times faster, which was fast enough to pass the performance test.

# Version 3
def currentCell
  $data[$datapointer] || 0
end
def inc i
  $datapointer = $datapointer + i
end
def plus i
  $data[$datapointer] = currentCell + i) % 256
end
def out
  print "#{currentCell.chr}"
end
def read
  $data[$datapointer] = $input.slice!(0)
  exit if !$data[$datapointer]
end
def append s
  $program << s << "
"
end

$program = ''
$data = []
$datapointer = 0

($code,$input) = STDIN.read.chomp.split '!'

(0..($code.size-1)).each {|i|
  tmp = $code[i]
  case tmp
    when 60,62: append "inc #{tmp-61}"
    when 43,45: append "plus #{44-tmp}"
    when 91: append "if currentCell != 0
begin"
    when 93: append"end while currentCell != 0
end"
    when 46: append "out"
    when 44: append "read"
  end
}
eval $program 

# Version 3 obfuscated
# 401 characters without this comment
def x
$d[$a]||0
end
def y i
$a=$a+i
end
def v i
$d[$a]=(x+i)%256
end
def t
print"#{x.chr}"
end
def u
$d[$a]=$k.slice!(0)
exit if !$d[$a]
end
def r s
$p<<s<<"
"
end
$p=''
$d=[]
$a=0
($c,$k)=STDIN.read.chomp.split'!'
(0..($c.size-1)).each{|i|
q=$c[i]
case q
when 60,62:r"y #{q-61}"
when 43,45:r"v #{44-q}"
when 91:r"if x!=0
begin"
when 93:r"end while x!=0
end"
when 46:r"t"
when 44:r"u"
end
}
eval $p

What's next?

I had a lot of fun writing these different versions. But now I'm stuck. I don't have the slightest clue on how to get to an even shorter piece of code. I already tried to add a method which generates the methods currentCell, inc, etc. but the overhead of one added method was more than what I gained by removing def and end.
I'm still thinking about other possible techniques to move towards the 142 byte by carldr. I believe there is a trick that uses special knowledge of the Brainfuck language I just don't have. If anybody has some generic hints on how to write shorter Ruby code, please leave a note

jboss.org/wiki:
hsqldb is not a production quality database.

I haven’t found a good tutorial, even the JBoss Developer’s Notebook wasn’t exhaustive, so here are my notes:

How to remove the hypersonice db from JBoss

1. Remove datasource:
   delete deploy/hsqldb-ds.xml
2. Add new datasource:
   for MySql add a file named deploy/mysql-ds.xml or whatever you like with something like:

   <datasources>
       <local-tx-datasource>
           <jndi-name>MySqlDS</jndi-name>
           <connection-url>jdbc:mysql://localhost:3306/datasource</connection-url>
           <driver-class>com.mysql.jdbc.Driver</driver-class>
           <user-name>myuser</user-name>
           <password>mypwd</password>
           <exception-sorter-class-name>
               org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter
           </exception-sorter-class-name>
   
           <metadata>
               <type-mapping>mySQL</type-mapping>
           </metadata>
       </local-tx-datasource>
   </datasources>

   You should use MySqlDS as the jndi-name or you have to edit mysql-jdbc2-service.xml later

3. Use new datasource:
   find all references to DefaultDS and replace them with MySqlDS and all references to Hypersonic SQL with mySQL
4. Configure jms:
   delete deploy/jms/hsqldb-jdbc2-service.xml and replace it with doc/examples/jms/mysql-jdbc2-service.xml and don’t forget to edit mysql-jdbc2-service.xml

   Edit the persistence configuration and change the line :-

   SELECT_MAX_TX = SELECT MAX(TXID) FROM (SELECT MAX(TXID) AS TXID FROM JMS_TRANSACTIONS UNION SELECT MAX(TXID) AS TXID FROM JMS_MESSAGES)

   to: -

   SELECT_MAX_TX = SELECT MAX(TXID) FROM JMS_MESSAGES

Blocks and closures are one of the reasons why you can do magic in Ruby. Some time ago I read Eli’s Understanding Ruby blocks, Procs and methods which does a great job of explainig the whole topic. As long as it doesn’t involve some high-level ruby magic (like Why’s A Block Costume) I felt like I understood most of the code using closure-like constructs.

When I used closures in my own code, every once in a while something would not work the way I expected it to. I always found a workaround and never spend much time worrying about these oddities.

This morning (via Ruby Inside) I found closures-in-ruby.rb by Paul Cantrell. Seems like he had the same problems but instead of ignoring them he played around and documented the things he found out. The article highlights some suprises and differences between the 7 ways of creating closure-like thingies in ruby. Highly recommended reading!

RedHanded

RedHanded is Why’s (from Why’s (Poignant) Guide to Ruby) blog. I don’t really know why I didn’t check out his blog earlier when I read WPGtR but I didn’t.

But I think this was a good thing, because I already knew a little bit about Ruby when I stumbled over his blog. This made reading his dazzling display of ruby magic more fun, like watching a stage magician with a slight chance of understanding and appreciating his tricks.

Go and check out bits and inspect. My all time favorint post is Camping Microframework, the code is cryptic and I cannot say I understand it but the whole post is hilarious (here is the real docu for Camping, a <4kb webframework).

Shades of Gray

In another post on this blog I asked for advanced articles on ruby and Pat pointed me to Shades of Gray. I already knew the author James Edward Gray II as the organizer of the Ruby Quiz. Shades of Gray contains exactly the kind of articles I was looking for all the time. The only sad thing is that it contains only a handful of these articles. His Higher Order Ruby posts provide Ruby translations of the example code from the book Higher Order Perl, his Ruby tutorials are among the best I’ve ever read and his other posts are worth reading, too.

If you read only a single sentence about good ruby style, it should be this one from Code as a Data Type:

In my experience, you know you’re doing Ruby right when you are dropping code and gaining functionality

This is true for almost any language, but in Ruby it is especially elegant to do. I guess this is the reason why I like programming in Ruby, it gives you the ability to write very compact but still readable code.

I’m getting pretty close to the present, but I hope I will find enough content for another post in this series so check again later…

BTW, if you have recommendations with other sites/articles/books on good ruby style, please let me know.

Ruby-talk

From ruby-lang.org I followed some links to the Ruby FAQ. Like the tutorials I read, the FAQ itself answered only questions regarding the language Ruby but lacked information about ‘good style’ or ‘the Ruby Way’. But the FAQ pointed me to the Ruby Talk Mailinglist. A few minutes later I was subscribed and messages started to come in[1]. There are just too many good posts to single out just a few. The mailing list archive (sorry) sucks, but fortunately the list is replicated via a ML-NetNews gateway with comp.lang.ruby which makes it possible to search for old posts via groups.google.com etc.

Ruby Quiz

After some time I noticed these strange posts to ruby-talk which had a [QUIZ] in the subject. I found the answer on rubyquiz.com:

What Is Ruby Quiz?
Ruby Quiz is a weekly programming challenge for Ruby programmers in the spirit of the Perl Quiz of the Week. A new Ruby Quiz is sent to the Ruby Talk mailing list each Friday. (Watch for the [QUIZ] subject identifier.) After a 48 hour no-spoiler period has passed, everyone is invited to contribute solutions and/or discussion back to the list. The following Thursday a Summary will be sent to the list, discussing the quiz, solutions and discussion. The next day, the cycle begins again.

The quiz is run by James Edward Gray II, who collects the solutions and writes a summary. A collection of quiz questions and solutions can be found on rubyquiz.com.

My favorites:

• Roman Numerals (#22)
  the last part, about how to add Roman Numeral Constants
• Code Cleaning (#26)
  how to unobfuscate Ruby code
• HighLine (#29)
  useful and I did learn something
• SerializableProc (#38)
  magic, especially Florian’s solution
• Sodoku Solver (#43)
  I like sudokus and I like Ruby…
• Dice Roller (#61)
  the old roleplayer came through, this was the first quiz I played around with

PLEAC – Programming Language Examples Alike Cookbook

Another link I found via the FAQ was PLEAC-Ruby, a cookbook with a huge number of code samples. BTW, the PLEAC Project has cookbooks for other languages, too. Most of the examples were pretty obvious, but I recommend browsing through

• Arrays and Hashes, just to see more examples on what to do with them
• Patternmatching if you can’t remember all the regex magic
• Packages etc. and Classes etc.

But like most of the documentation found online, it was more about code and less about style.

Check back later, there is still more to come

[1] I read my share of mailinglists, but ruby-talk is the only list with such a high volume which still has a low rate of flamewars, bashing, etc. Keep it up guys, even though I don’t write much, I really like reading this list.

I heard about Ruby some years ago. I can’t remember where it was, must have been one of those perl newsgroups or mailinglists I was reading. The description was always something like “Japanese Perl Clone with better Object-Orientation” which sounded neat. But as I was using Perl only for small scripts, it was not enough to make me look into the language. Last year the buzz around Ruby on Rails gave me the final push and I started to learn Ruby. This series of posts describes my learning process.

Tutorials

The first tutorial I stumpled upon was Why’s (Poignant) Guide to Ruby (WPGtR) which is the funniest tutorial for a programming language I ever read, but it somehow failed to teach me Ruby (I read it again later and by now I think it’s great – perhaps I just had a bad day).

But WPGtR showed me enough of Ruby to make me buy Programming Ruby. I really enjoyed Dave Thomas’ style and read the whole book in just a few days. I highly recommend this book to anyone learning Ruby. If you want some samples first, the whole first edition of Programming Ruby is online. I don’t like reading online, but I use it sometimes to lookup stuff.

Just for completeness sake, I read a few pages of the Programming:Ruby wikibook. It is still in the making, but I hope it will become a useful resource sometime.

There are countless other tutorials out there. I just skimmed through Learn To Program and The Little Book Of Ruby (LBOR) and both look pretty good at first glance. If you (like me) prefer to read your stuff offline, I recommend WPGtR or LBOR which offer pdf versions.

After these three tutorials I knew how to write Ruby. But I was writing these programs in the same way I wrote my Java or Perl programs, without using any of the interesting Ruby features.

Rubygarden

I found the first hints on how to improve my code on the Rubygarden wiki. I highly recommend reading at least the following few pages. There is a lot more to be found in the wiki, but like all wikis it’s damn hard to get to the good bits.

• RubyIdioms
  examples which show the difference between the naive way and The Ruby Way
• RubyStyleGuide
  coding conventions and some programming conventions which I found not as useful as the idioms above.
• RubyNuby
  a link page with pointers to a lot of useful resources in the wiki
• StandartClassExtensions
  extensions for standart classes, contains interesting code samples. I found this more useful than the RubyOnlineCookbook.
• ExampleDesignPatternsInRuby
  Code samples for some design patterns

The journey continues here.

Bloated Exceptionhandling

Why do I have to write so much more code to get a reliable solution? Part of the blame is on Java, because of its verbose exception handling – there is no elegant way of catching 2 or more exceptions[1] without catching Exception or Throwable, which I try to avoid where possible. Ruby has this simple solution compared to the bloated solution in java, especially with EJB where you have to catch half a dozend different exceptions.

begin
  eval string
rescue SyntaxError, NameError => boom
  print "String doesn't compile: " + boom
rescue StandardError => bang
  print "Error running script: " + bang
end

Retry

Repeating whole blocks of code needs too much code, too. Ruby has the retry command, which restarts the current block:

c = 0
for i in 1..100
  tries = 0
  begin
    c = c + 1                 # dummy code
    if c % 4 != 0             # to create
      puts "failed for #{i}"  # a few
      raise "uups"            # exceptions
    end
    puts "action #{i}"
  rescue
    puts "rescue"
    tries = tries + 1
    retry if tries < 3
  end
end

This is just another name for goto, which might be harmful. Actually, I wouldn’t use this solution anyway because there is a better, more reusable way, to achieve the same.

closures

In ruby, it is possible (and very simple) to pass some code to a method. This allows me to create a method which excecutes my code multiple times, if an exceptions occurs:

def try(max_tries = 3)
  tries = 0
  begin
    yield
  rescue
    puts "rescue"
    tries = tries + 1
    retry if tries < max_tries
  end
end

c = 0
for i in 1..100
  try do
    c = c + 1                 # dummy code
    if c % 4 != 0             # to create
      puts "failed for #{i}"  # a few
      raise "uups"            # exceptions
    end
    puts "action #{i}"
  end
end

When I started this article, I just wanted to write a short rant about the missing features for errorhandling in java. While writing, I noticed that Ruby has them. Perhaps that’s the reason why I enjoy programming in ruby so much

[1]to clarify this point just for Jason: In general, there is no elegant way of catching two or more exceptions. If you look at the number of direct subclasses in java.lang.Exception, it is nearly impossible to catch the exceptions you want using a superclass without catching some ‘innocent bystanders’.
I would very much like to see a elegant solution which catches only java.sql.SQLException and java.util.concurrent.TimeoutException, you may use as much OOP and polymorphism as you like. This might not be the fault of the language but the plattform but as I cannot get one without the other, it doesn’t really matter to me. Don’t get me wrong, I think Java is pretty damn good, but there is still a lot of room to improve. And Ruby is showing some of the things which can be done better.

This tutorial shows how to use distributed ruby to connect a rails application with another ruby service not running inside Rails.

Distributed Ruby (DRb)

I won’t waste time here explaining how to use DRb. Just a short example from Rubycentral with a very simple server:

require 'drb'

class TestServer
  def doit
    "Hello, Distributed World"
  end
end

aServerObject = TestServer.new
DRb.start_service('druby://localhost:9000', aServerObject)
DRb.thread.join # Don't exit just yet!

and an even simpler client:

require 'drb'
DRb.start_service
obj = DRbObject.new(nil, 'druby://localhost:9000')
# Now use obj
puts obj.doit

Active Record

As you want to connect the DRb Server to Rails, you probably want to use your model classes, too. Just include them (I’m still looking for a simple way to automagically include all models) and configure ActiveRecord:

require 'drb'
require 'rubygems'
require_gem 'activerecord'

require 'app/models/user.rb'

class Server
  def dump
    puts User.find(:first).inspect
  end
end

ActiveRecord::Base.establish_connection(
    :adapter  => "mysql",
    :username => "xxxx",
    :host     => "localhost",
    :password => "xxxx",
    :database => "xxxx"
)

DRb.start_service("druby://localhost:9000", Server.new)
puts DRb.uri
DRb.thread.join

Don’t repeat yourself!

Repeating the database configuration as I did in the above example is soooo against The Ruby Way. A better way is to parse config/database.yml and use the result to configure ActiveRecord. This has the added benefit of being able to use different database setups:

require 'drb'
require 'rubygems'
require 'yaml'
require_gem 'activerecord'

require 'app/models/user.rb'

class Server
  def dump
    puts User.find(:first).inspect
  end
end

abort "usage: #{__FILE__} environment" unless ARGV[0]
database_yaml = YAML.load_file("config/database.yml")
abort "environment '#{ARGV[0]}' not found" unless database_config = database_yaml[ARGV[0]]

ActiveRecord::Base.establish_connection(database_config)

DRb.start_service("druby://localhost:9000", Server.new)
puts DRb.uri
DRb.thread.join

From Rails?

Just use the simple client from above inside your model or controller without special changes for Rails. Yes, it’s that simple. Enjoy!

require 'drb'
...
class DrbController < ApplicationController

  def get_user_via_drb
    DRb.start_service
    obj = DRbObject.new(nil, 'druby://localhost:9000')
    @user = obj.dump
  end 

Here is a short thread about problems with DRb.

DRb over unix sockets

Brian has a nice writeup how to use DRb over unix sockets – it’s extremly easy, just change the URI et voila…

Technorati Tags: ruby, rails, drb

UNIX is user-friendly, it’s just picky about who it’s friends are.

This definitely is true for linux as well. And today I got one step closer to being Linux’ best friend.

When I googled for “dvd ide linux” I read in most articles that you can’t burn DVDs on an IDE drive if you don’t enable SCSI emulation in the kernel. So I tried to do that, everything went fine until I tried to make my boot loader (yes, I know Lilo is deprecated in favour of grub) decided to announce a floating point error rather than writing the new config to the boot sector. Meanwhile, I had found some hints that with 2.6 Kernels SCSI emulation was o longer required and that cdrecord would recognise IDE drives as well. And it did indeed:

$ cdrecord --scanbus dev=ATAPI
scsibus0:
0,0,0 0) 'TEAC ' 'DV-W58G-A ' 'U4S2' Removable CD-ROM

That doesn’t mean xcdroast is willing to burn a DVD, though. It works fine for CD-ROM, but with DVDs it complains that it can’t find the SCSI driver for some strange device I didn’t even know my computer had.
Then I read the name growisofs in some forum thread and I looked it up and landed on the DVD+RW/+R/-R[W] for Linux page. I had seen that before but was scared away by all that talk about kernel patches and stuff. Now I read on and it looked very promising and very simple. A quick

emerge -va dvd+rw-tools

installed the package and I was ready to go:

growisofs -Z /dev/hdc -R -J /home/schlumpf

writes the data from the directory /home/schlumpf to the dvd device /dev/hdc, writes a header (the -Z param; use it for DVD+R) and writes Rock Ridge protocol (-R) and Joliet (-J) extended information on the disk.
By the way, growisofs is only a frontend for the mkisofs command which should be present in nearly all linux installations.

This is a prime example of the power and curse of Linux: some things are so simple you just don’t think of them!
Here’s another: How to read a file backwards? Reverse cat: tac.

I read about ‘The Java Posse’ in Bruce Eckel’s blog. I really like the short transcript containing a collection of related links with each cast. Here’s my very short review of the interviews I heard so far.

001.mp3	Interview with Rob Harwood of Jetbrains about IntelliJ IDEA	64:23
	How much did IntelliJ pay for this advertisement? Boring marketing speech. Skipped to the next episode after 40 minutes.
002.mp3	NewsCast for Sept 29 2005	31:02
	Old news, but there was still some stuff I didn’t know. The voice of the second guy (Carl?) sounded like he was talking into a bucket. I will skip the other old NewsCast and stick to interviews.
	pointer: Annotations: Don’t Mess with Java
003.mp3	Interview with David Barnes about BlueJ	36:06
	How well is Java suited to teaching programming? Introducing BlueJ an Java IDE for beginners. Terrible music at the end.
	pointer: bluej.org
005.mp3	Interview with Chuck Hill about WebObjects	28:54
	A short intro into WebObjects.
007.mp3	Interview with Cameron Purdy of Tangosol	43:33
	Grid Computing, a lot of buzzwords, java.nio
009.mp3	Interview with Josh Bloch of Google	41:20
	nice chit chat about java

Google has extensive information how to use Google Talk but no info for kopete users like me. This is a step by step description, how to configure kopete.

First, you might need to install an additional package called tca-tls or similar, if it’s not already present. It seems every distribution has a slightly different name for the same thingy:

When you have installed this package, the most difficult part is probably over, the actual setup is pretty simple:

1. Settings->Configure
2. New
3. Next
4. Select Jabber
5. On the first tab enter your account information

   Basic Setup
        Jabber Id: [xxxx@gmail.com]
    [ ] Remeber Password whatever you prefer
        Password: [xxxx]
   

6. On the second tab enter

   Connection
    [x] Use protocol encryption (SSL)
    [x] Allow plain-text password authentication
    [x] Override default server information
        Server: [talk.google.com]         Port: [5223]
   

enjoy …

Related Posts:

• How to remove old kopete status messages
• Install new themes for kopete

Technorati Tags: GoogleTalk, gtalk, kopete

A growing list of things I don’t want to forget…

Disclaimer:

This is still very beta! AFAIK there are no errors on this page, but a lot of stuff is still incomplete.

Sections

• General
• Ruby
• Rails
• Model
• View
• Features
• Books

General

Setup for debian

Install the following packages:

• ruby – An interpreter of object-oriented scripting language Ruby
• irb – Interactive Ruby
• ri – Ruby Interactive reference
• rdoc – Generate documentation from ruby source files
• libmysql-ruby – MySQL module for Ruby

For the first few steps I highly recommend toying around with irb, an interactive ruby shell.

apt-get install ruby irb ri rdoc libmysql-ruby

Useful gems

• actionmailer – Service layer for easy email delivery and testing.
• actionpack – Web-flow and rendering framework putting the VC in MVC.
• actionwebservice – Web service support for Action Pack.
• activerecord – Implements the ActiveRecord pattern for ORM.
• activesupport – Support and utility classes used by the Rails framework.
• db_structure – [Rails] Database utilities.
• localization_generator – [Rails] Localization generator.
• rails – Web-application framework with template engine, control-flow layer, and ORM.
• rake – Ruby based make-like utility.
• salted_login_generator – [Rails] Login generator with salted passwords.

gem install actionmailer actionpack actionwebservice activerecord activesupport db_structure localization_generator rails rake salted_login_generator

Ruby Developer Tools for Eclipse

• Help->Software Updates->Find and Install
• “Search for new features to install”, click Next
• “New Remote Site”
• name: whatever you like, “Ruby Developer Tools” would be sensible, URL: http://rubyeclipse.sf.net/updatesite, click OK
• select RDT, click Next
• select RDT again, click Next

Online documentation

• api.rubyonrails.org/
  read these:
  • ActionController:Base API Doc
  • FormHelper API Doc
  • UrlHelper API Doc

Support

• Rails Mailinglist
• #ruby-talk
• #rubyonrails

Ruby

attr_accessor :name
attr_reader   :name
attr_writer   :name

Rails

Rails configfiles

• config/boot.rb: don’t touch
• config/database.yml: database config for all environment
• config/environments/(development|production|test).rb: config which differs between environments
• config/environment.rb: global config
• config/routes.rb: configure mapping of urls to controllers and actions

Environments

Start server for the different environments:

ruby script/server -e development|test|production

script/generate

ruby script/generate controller $controller
ruby script/generate controller $controller $action1 $action2 $action3
ruby script/generate scaffold $model $controller
ruby script/generate model $modelname

Model

• Module ActiveRecord::Associations

Naming conventions

• Class names: CamelCase, MyEntry
• Table names: lowercase_underscores_plural, my_entries

finder

User.find(:all, :conditions => ["login != ?", user.login])

table joins

user table with user table in friends table (columns user_id and friend_id)

has_and_belongs_to_many :friends, :join_table => 'friends', :class_name => 'User', :foreign_key => 'friend_id'

has_and_belongs_to_many :friends_of, :join_table => 'friends', :class_name => 'User', :foreign_key => 'user_id', :association_foreign_key => 'friend_id'

creates for example for friends the following methods:

• add_friends
• friends
• friends=
• friends_count
• has_friends?
• remove_friends
• validate_associated_records_for_friends

View

ERb

• <%= returns value %>
• <% just execute this %>
• no newline afterwards if closed with -%>

render

render :action => "goal"
render :action => "short_goal", :layout => false
render :action => "long_goal", :layout => "spectacular"

# partials always start with a '_' e.g.  _win.r(html|xml)
render :partial => "win"
render :partial => "broken", :status => 500
render :partial => "win", :locals => { :name => "david" }

# render partial for every item in collection
render :partial => "win", :collection => @wins
render :partial => "win", :collection => @wins, :spacer_template => "win_divider"

form helpers

form_tag :controller=>"user", :action=>:login

text_field(:variable, :attribute, :size => 16)
hidden_field(:variable, :attribute, :maxsize => 16)
password_field(:variable, :attribute)

size and maxsize are optional parametes for *_field

other helpers

stylesheet_link_tag "main", :media => 'all'
stylesheet_link_tag "main","second", :media => 'all'

create one / two stylesheet <link>s.

Features

Login

• the original LoginGenerator
• newer, better: SaltedHashLoginGenerator
• even newer and even better LoginEngine

Books

There are a lot of good articles available about how to customize the layout of you blog but sometimes want to add some kind of outside information to your blog. For complex or large amounts of information, you should consider a database solution but in a lot of cases a simple file based solution works, too. This tutorial shows you how to add information from a file to your blog.

Recently I added a “Just read” block to my sidebar containing links and images to the books I have read and a rating. At first this was a static html block, just to see how it will look. Lazy as I am, I didn’t want to write html every time I finish a book. This is why I moved the information from the sidebar.php into a seperate file called books.txt in the main directory of my blog.

The file

The file contains 5 tab seperated columns for author, title, amazon url, amazon image url and url for the rating image. A sample line looks like this:

Dave Thomas<tab>Programming Ruby<tab>http://www.amazon.de/exec/obidos/ASIN/0974514055/<tab>http://images-eu.amazon.com/images/P/0974514055.03.MZZZZZZZ.jpg<tab>/pics/stars-2-5.gif

Reading and parsing the file is pretty easy in php (this is taken directly from the php manual):

$lines = file('books.txt');
foreach ($lines as $line_num => $line) {
  $parsed = explode("\t", rtrim($line));
  ...
}

As I wanted only the first 4 books to show, I added a check to echo only the lines with a line number less than 4. rtrim removes the whitespaces/newlines from the end of the line and explode splits the line at every tab. This leaves me with an array of 5 strings. The final step of assembling an entry for a book within a <td> is straightforward. After every 2 books a </tr><tr> is added to create a 2×2 block of books.

Here’s the whole block, as it is used in my sidebar, if you have any questions feel free to ask…

<li><h4>Just read</h4>
  <table>
    <tr>

<?php
$lines = file('books.txt');
foreach ($lines as $line_num => $line) {
  if ($line_num < 4) {
    $parsed = explode("\t", rtrim($line));

    $book_author = $parsed[0];
    $book_title = $parsed[1];
    $book_url = $parsed[2];
    $book_img = $parsed[3];
    $book_rate = $parsed[4];
    echo "<td><a title=\"$book_author - $book_title\" href=\"$book_url/frankspycha0b-21/\"><img src=\"$book_img\"/><br/><img src=\"$book_rate\"/></a></td>\n";
    if ($line_num % 2 == 1) {
      echo "</tr><tr>\n";
    }
  } else {
    break;
  }
}?>

    </tr>
  </table>
</li>

There is a simple workaround, which sadly wastes a lot of cpu cycles, but I can’t think of another simple solution with less overhead.

1. parse document with schema validation and XInclude, if there is no exception (which should be the default case) return result
2. if there is an exception parse document again with XInclude but without schema validation
3. if there is another exception, throw this exception (something is wrong with XInclude)
4. write the result to String and parse the String yet again, this time with schema validation but without XInclude (we included everything in the second step)
5. this will fail again, but the exception will include a useful errormessage

public class XInclude {
  private static final XMLOutputter XMLO = new XMLOutputter();

  private static Document doParse(String file, boolean val, boolean xinlcude, boolean fixbase, boolean fixlang) throws JDOMException {
    final SAXBuilder saxB = new SAXBuilder(val);
    saxB.setFeature("http://apache.org/xml/features/validation/schema", val);
    saxB.setFeature("http://apache.org/xml/features/xinclude", xinlcude);
    saxB.setFeature("http://apache.org/xml/features/xinclude/fixup-base-uris", fixbase);
    saxB.setFeature("http://apache.org/xml/features/xinclude/fixup-language", fixlang);
    return saxB.build(file);
  }

  private static Document parse2(String file) throws JDOMException {
    try {
      return doParse(file, true, true, false, false);
    } catch (JDOMException jde) {
      final Document doc = doParse(file, false, true, false, false);
      final String included = XMLO.outputString(doc);
      final SAXBuilder saxB = new SAXBuilder(true);
      saxB.setFeature("http://apache.org/xml/features/validation/schema", true);
      saxB.setFeature("http://apache.org/xml/features/xinclude/fixup-base-uris", false);
      saxB.setFeature("http://apache.org/xml/features/xinclude/fixup-language", false);
      return saxB.build(new StringReader(included));
  }
}

  public static void main(String[] strings) throws JDOMException {
    try {
      doParse("xinclude/test.xml", true, true, false, false);
    } catch (JDOMException jde) {
      System.out.println(jde.getMessage());
    }
    parse2("xinclude/test.xml");
  }
}

For this example I use the following documents:

• main.xml the main document, imports include.xml
• include.xml the included document, contains just a single element
• main.xsd a simple schema for the main document

main.xml
<?xml version="1.0"?>
<root xmlns="http://main.xml"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:xi="http://www.w3.org/2001/XInclude"
      xsi:schemaLocation="http://main.xml
      file:///<i>path to schema</i>/main.xsd">

  <e id="1"/>
  <e id="2"/>
  <e id="3"/>
  <b><xi:include href="include.xml"/></b>
  <e id="4"/>
  <e id="5"/>
  <e id="6"/>
</root>

And this is the included file:

include.xml
<?xml version="1.0"?>
<e xmlns="http://main.xml" id="23"/>

and a very simple Schema to validate the file:

main.xsd
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema targetNamespace="http://main.xml"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns:sn="http://main.xml"
  elementFormDefault="qualified">

  <xsd:element name="root">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="e" type="sn:elementType" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:complexType name="elementType">
    <xsd:attribute name="id" type="xsd:string" use="required"/>
  </xsd:complexType>
</xsd:schema>

The solution seems obvious, use a SAXParser and set the features for Schema Validation and XInclude to true.

final SAXBuilder saxB = new SAXBuilder("org.apache.xerces.parsers.SAXParser", true);
saxB.setFeature("http://apache.org/xml/features/validation/schema", true);
saxB.setFeature("http://apache.org/xml/features/xinclude", true);
saxB.build("main.xml");

Sadly, it fails with Exception in thread "main" org.jdom.JDOMException: Error on line 12 of document a pathmain.xml: Error attempting to parse XML file (href='include.xml'). Line 12 is the line containing the XInclude statement which suggested an error in the syntax. But multiple rereads of the spec didn’t help so turned off Schema Validation for a change. Now everything worked fine and a look at the document shows what went wrong with the Schema Validation:

<?xml version="1.0" encoding="UTF-8"?>
<root xmlns="http://main.xml"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:xi="http://www.w3.org/2001/XInclude"
      xsi:schemaLocation="http://main.xml
      file:///<i>path to schema</i>/test.xsd">

  <e id="1" />
  <e id="2" />
  <e id="3" />
  <e id="23" <b>xml:base="include.xml" </b>/>
  <e id="4" />
  <e id="5" />
  <e id="6" />
</root>

Xerces inserts a xml:base attribute when in insert an element and this attribute is not allowed in my Schema. But fortunately I don’t have to change my schema to suit this. There’s a feature called fixup-base-uris (http://apache.org/xml/features/xinclude/fixup-base-uris) which removes these additional attributes.

final SAXBuilder saxB = new SAXBuilder("org.apache.xerces.parsers.SAXParser", true);
saxB.setFeature("http://apache.org/xml/features/validation/schema", true);
saxB.setFeature("http://apache.org/xml/features/xinclude", true);
saxB.setFeature("http://apache.org/xml/features/xinclude/fixup-base-uris", false);

This works fine, with one minor problem left: if there is an error in the included XML document, it fails with Exception in thread "main" org.jdom.JDOMException: Error on line 12 of document file:a path/main.xml: Error attempting to parse XML file (href='include.xml'). which is not very helpful. I’ll post a workaround for this problem tomorrow.