In the end, it’s better to avoid creating stubborn dragons in the first place and to slay them early if they start to turn bad. Young dragons are easier to slay than old ones. You may even slay several dragons before you are happy that you have one you can live with.

Image source

The rumor mill says, that we will soonish see tons of interesting Javascript and Ruby stuff there .. thanks to one project in winter country :-).

Dakota tribal wisdom says that when you discover you are riding a dead horse, the best strategy is to dismount. However, in business we often try other strategies with dead horses, including the following:

• Buying a stronger whip.
• Changing riders.
• Say things like, "This is the way we have always ridden this horse."
• Appointing a committee to study the horse.
• Arranging to visit other sites to see how they ride dead horses.
• Increasing the standards to ride dead horses.
• Appointing a tiger team to revive the dead horse.
• Creating a training session to increase our riding ability.
• Comparing the state of dead horses in todays environment.
• Change the requirements declaring that "This horse is not dead."
• Hire contractors to ride the dead horse.
• Harnessing several dead horses together for increased speed.
• Declaring that "No horse is too dead to beat."
• Providing additional funding to increase the horse’s performance.
• Do a Cost Analysis study to see if contractors can ride it cheaper.
• Purchase a product to make dead horses run faster.
• Declare the horse is "better, faster and cheaper" dead.
• Form a quality circle to find uses for dead horses.
• Revisit the performance requirements for horses.
• Say this horse was procured with cost as an independent variable.
• Promote the dead horse to a supervisory position.

Nice thread int he extremeprogramming-ML

You can get the entire book at Projet Gutenberg for free.

 hdiutil burn image.iso

 $ hdiutil  burn  KNOPPIX_V5.1.1CD-2007-01-04-EN.iso
 Preparing data for burn
 Opening session
 Opening track
 Writing track
 ..............................................................................
 Closing track
 ..............................................................................
 Closing session
 ..............................................................................
 Finishing burn
 Verifying burn...
 Verifying
 ...............................................................................
 Burn completed successfully
 ...............................................................................
 hdiutil: burn: completed

Good old trusted linux does it with cdrecord :-)

 cdrecord  speed=2 dev=0,1,0 -data sol-9-install-sparc.iso

 Hi all,

 Long time since I announced my last project....

 With RubyJS you can transform a subset of Ruby into Javascript code.

 What works?
 * Classes, modules, inheritance
 * Instance methods, class methods
 * Exceptions (rescue/ensure)
 * Meta-programming stuff like 'attr_reader'
 (any meta-programming stuff works that does not appear inside methods)
 * Iterators, yield
 * "require" (with platform-specific extension ala Google Webtoolkit)
 * Inline Javascript code
 * Some kind of compile-time method lookup  ;-)
 * Numbers, String, Array, Hash, Proc (a lot of functionallity is missing!)
 * Testing with Rhino-JS
 * A lot more  :)

 There is a lots of room for optimizations and improvement  :)

 DOWNLOAD
 http://ntecs.de/hg-projects/rubyjs/

 Best use Mercurial (www.selenic.com/mercurial) to check it out:
 hg clone static-http://ntecs.de/hg-projects/rubyjs/

• Merge PDF Documents
• Split PDF Pages into a New Document
• Rotate PDF Pages or Documents
• Decrypt Input as Necessary (Password Required)
• Encrypt Output as Desired
• Fill PDF Forms with FDF Data or XFDF Data and/or Flatten Forms
• Burst a PDF Document into Single Pages
• ..

The nice thing is that one can use it all from the commandline :-).

• Examples Merge Two or More PDFs into a New Document

 pdftk 1.pdf 2.pdf 3.pdf cat output 123.pdf

• Split Select Pages from Multiple PDFs into a New Document

 pdftk A=one.pdf B=two.pdf cat A1-7 B1-5 A8 output combined.pdf

• Burst a Single PDF Document into Single Pages and Report its Data to doc_data.txt pdftk mydoc.pdf burst.

It’s a jewel one should have in its tool-shop.

 Let me relate a few war stories...

 Once I had a very very complex problem to solve.

 I had not the foggiest notion in which order to compute what.

 So I took the cowards way and hooked in the Observer all over the place
 so I didn't have to think in what order to do it.

 It was very slow and buggy and I was no closer to understanding in the
 problem than before. It did work occasionally though.

 I put in enough logging to see what order it did things in (when it
 worked). After glaring at that for an hour I saw the pattern, recoded
 it as a couple of tight while loops.

 Result...

 Very fast, very understandable, easily maintained, no bugs and no observers.

 Story two...

 Once I took over the maintenance of some code that had several
 observer pattern instances scattered around it.

 It was fragile, buggy, and erratic.

 After much loss of hair and many hours of poring over log traces I
 figured it out.

 There were complex loop paths through several observers. No mere
 mortal could really understand what would happen if object X updated,
 since the possible impacts and possible variants of paths were almost
 limitless and depended crucially on the order of registration of
 observers.

 After a brief killing spree amongst the instances of the observer
 pattern the code was still buggy, but at least no longer fragile and
 erratic...

groups.google.com/group/comp.lang.smalltalk.dolphin/msg/fae4a931c64f5311

Luis von Ahn is an assistant professor in the Computer Science Department at Carnegie Mellon University, where he also received his Ph.D. in 2005. Previously, Luis obtained a B.S. in mathematics from Duke University in 2000. He is the recipient of a Microsoft Research Fellowship.

ABSTRACT

Tasks like image recognition are trivial for humans, but continue to challenge even the most sophisticated computer programs. This talk introduces a paradigm for utilizing human processing power to solve problems that computers cannot yet solve. Traditional approaches to solving such problems focus on improving software. I advocate a novel approach: constructively channel human brainpower using computer games. For example, the ESP Game, described in this talk, is an enjoyable online game — many people play over 40 hours a week — and when people play, they help label images on the Web with descriptive keywords. These keywords can be used to significantly improve the accuracy of image search. People play the game not because they want to help, but because they enjoy it.

I describe other examples of "games with a purpose": Peekaboom, which helps determine the location of objects in images, and Verbosity, which collects common-sense knowledge. I also explain a general approach for constructing games with a purpose.