blog://gestalt.monoid.net

MS Fonts in Google Documents on Ubuntu

2009-11-27T17:56:00.001+01:00

A major reason why I love google documents is that I can access all the files from any computer regardless of the operating system. In principle this works great for me but unfortunately changing the text font (e.g. to Courier New) doesn't work on ubuntu. Although I still hope there is something goggle can do, the intermediate solution is using the 'Installer for Microsoft TrueType core fonts':

sudo apt-get install ttf-mscorefonts-installer

P.S. Don't forget to restart you browser afterwards.

MATLAB/Octave Utils: submat, grouped

2009-09-18T18:12:00.001+01:00

Totally forgot to share these two MATLAB/Octave functions I wrote some time ago:
submat: accessing a sub-matrix of an unknown multi-dimensional matrix
grouped: creating record like data structures from arrays grouped by an index cell

Actually, I still wonder if or why this functionality is not part of the core library or even the 'language syntax '? Anyhow, I couldn't find it so I wrote the two functions myself. (please tell me if you know about a predefined equivalent or a better solution)

1. submat ( submat.m )

In Matlab everything is a (potential) N-dimensional matrix of elements such as doubles, cells or structs. Sub-indexing is easy, unless you try to program in a generic way, e.g. with high-order functions. The problem is that traditional sub-indexing requires you to know the element type (cell or not) and dimensions of the matrix. So I came up with a function submat, which basically does sub-indexing in the highest dimension of an unknown type:


A = [ 1, 2, 3; 4, 5, 6 ];
submat(A,2:3)   % same as A(:,2:3)
-> [ 2, 3; 5, 6 ]

B = { 'Hello', 'submat'; 'Goodbye', '(:)' };
submat(B',1)  % same as B'{:,1}
-> { 'Hello', 'submat' }

2. grouped ( grouped.m )

The other thing I missed was a simple way to group data arrays to structs. Of course this can easily be done within a for loop, but using the group function eliminates the code repetition. Also, it can be be used in two ways:

First, it allows to simply group equal indices together.


grouped( [ 1, 2, 1, 3, 1, 2, 3] )
-> { [ 1, 3, 5 ], [ 2, 6 ], [ 4, 7 ] }

So far nothing special, but its main purpose is to create a custom struct array.

 
%artists  =  { 'Beatles', 'Bob Dylan' };
%records
record_artist_ids = [1, 1, 2, 2, 1];
% or the result of group(record_artist_ids)
record_artist_ids = { [1, 2, 5], [3, 4] };
title = { 'White Album', 'Rubber Soul', 'Blood on the Tracks', 'Blonde on Blonde', 'Revolver' };
year = [ 1968, 1965, 1975, 1966, 1966 ];

artist_records = grouped ( record_artist_ids, 'title', title, 'year', year)

-> artist_records(1).title = { 'White Album', 'Rubber Soul', 'Revolver' }
   artist_records(1).year = [ 1968, 1965, 1966 ]
   artist_records(2).title = { 'White Album', 'Rubber Soul', 'Revolver' }
   artist_records(2).year = [ 1975, 1966 ]

New Project: Team-Tactics

2009-09-17T02:31:00.005+01:00

So what is it about? Well, it's meant to be a playground for exploring intuitive and efficient ways to control/direct virtual entities - or simply a turn based football (soccer) game.

As some might know, my current research is about interaction metaphors for 3D scenes using novel input modalities (multi-touch, motion-sensors, video, ...). Thereby, a special focus lies on concurrent user interaction with both shared and networked devices. Although I might not be able to share much information about this before scientifically published, I believe the evaluation platform should be open right from the beginning. And why shouldn't it be something fun. A tactical football game will fit:

the rules are not too complicated to understand and implement

the big team size and typical player proximities are ideal for cooperative/competitive interaction

easy to realize in both 2D/3D as well as in various levels of abstraction

my Ph.D. supervisor is crazy about that football (!FC Barcelona!)

The gameplay will most likely consist of two repeating phases: First, the tactics are defined/adjusted by altering the players' next actions. Afterwards, all the movements are simulated concurrently. Hopefully, this 'genre' (half real-time tactics?) facilitates the strategic/tactical emphasis.

Except for this choice, everything else is still open. The idea is to prototype a lot and to find the most fun and intuitive concepts. (Clearly, the target audience includes casual gamers.)
I guess this is also the place to mention that help is always welcome: if you want to contribute design/interaction ideas, code, graphics, music/sounds or anything else - please let me know.

OK, that's it for now. If you're interested, please follow the dedicated blog at teamtacticsproject.blogspot.com - I intend to write a regular development diary and promise to write at least one post tomorrow.

Shell History Meme

2008-04-12T10:51:00.003+01:00

Reading YC's post about the meme happening at the Fedora Planet, I also gave it a try:

history | awk '{a[$2]++ } END{for(i in a){print a[i] " " i}}'|sort -rn|head

113 cd
88 ls
53 hg
38 ant
28 fsc
23 ln
17 ssh
13 java
10 ../../../bin/java
9 scala

In words:
I am guy who likes to be at many places [cd] and to know the surroundings [ls] - I try to keep record of everything [hg]. Further, I don't want to bother with annoying repetitive tasks: things should be done automatically [ant] and fast [fsc]. Mental links [ln] help me not to get lost while my mind is far away [ssh]. Finally, you know I used to program in Java [java,../../../bin/java] but nothing can stop the rise of Scala [scala]. ;-)

A new Scala Bundle for Textmate

2008-02-02T03:37:00.002+01:00

No doubt, the upcoming Scala Module will make Netbeans the No.1 Scala IDE. I use the current pre-release version on my linux box at work without any difficulties. Unfortunately, I have encountered problems running the recommended daily development builds of Netbeans on my private macbook pro. I hoped that I could at least use my favorite editor for MacOS X, Textmate, but the bundle shipped with Scala 2.6.1 still seems to be a dummy/placeholder. Well, instead of falling into a deep depression, I invested half a day to create a new bundle myself.

For those interested, please find the download below:

- The Scala Bundle
- An Example Project (with some sources ripped from scala-lang.org)

The main goal was to have simple syntax highlighting, which actually looks quite good using the 'Cobalt Theme'. (I'm not 100% sure that value:Type is always displayed correctly, but it seemed to work with the samples.)

Further, there is a template for an Ant-Script which includes a compile, run & deploy task. These can be executed as bundle commands (menu or shortcuts), if the file is called 'build.xml'. Customization should be easy with a few properties at the top of the file.

Finally, there are a few snippets to write new code quickly. E.g. typing

trait ->| Adder ->| def ->| add ->| Int ->| 2 ->| left ->| Int ->| right ->| Int

results in

/**
 * Adder
 */
trait Adder
{
    def add ( left : Int, right : Int )  : Int
}

without pressing two keys at the same time (no SHIFT)!

But of course you can sketch your own (and share them with me =) ) !

Streams for Incremental and Tail-Recoursive Computing

2007-10-18T16:15:00.001+01:00

Programming in Scala is a lot of fun for me, but I really love Streams. Their laziness allows really nice implementations of incremental algorithms and tail-recursive functions. the best thing is they can be used efficiently under different requirements: no matter if you are interested in each intermediate result or only the final one, you'll only need one implementations. =)

I hope the following example computing the factorial(s) using Streams explains it well:

Building Scala from the Sources

2007-10-17T14:11:00.001+01:00

As I noticed that the actual Scala sources include a great enhancement for all RandomAccessSeq.Mutables, such as Array or ArrayBuffer: Now, the methods drop, take, slice and reverse return a RandomAccessSeq.MutableProjection, which allows cool things to be done in O(1), e.g. Array(1,2,3) reverse(0) = 10.

Unable to hold mysself back waiting, I decided try the latest version. All I had to do was to follow these instruction: Building Scala 2 from the sources. Et viola, one can already taste some of the features/fixes scheduled for Scala 2.6.1. =)

11 Amazingly Simple Tricks To Turn Your Brain Into A Powerful Thinking Machine

2007-10-06T09:20:00.000+01:00

Today, I enjoyed reading the article 10 Amazingly Simple Tricks To Turn Your Brain Into A Powerful Thinking Machine. Actually, my life includes most of the them since quite a time, except for points 4 and 9. Ok and the first "trick" I only do partly, because I don't focus that much on varying the the subjects - but who's perfect. ;-)

However one important thing is left on the list, maybe because it is not so simple as the others:

0. Exercise every 1 or 2 days

It has been shown recently, that for adults the only way to create new brain cells is exercise. Especially these greatly improve learning and memory, if combined with the daily brain training like described in 1-10. The reason is that the new cells get instantly inserted into the neural network where needed, which is a faster process than optimizing by transforming/rebuilding it.
So this is really step zero, since without challenging the mind (brain training, learning), the new cells will not be linked strong enough and therefore will die within a few weeks.

Regularly sport and fitness exercises are great, but I believe not using the elevator for changing only 1-3 floors and going small distances by foot or bike are nice additions.

[1] First Proof that Exercise Creates New Cells in Brain Area Affecting Age-Related Memory Loss
[2] Das Wundermittel namens Bewegung - Hirnforscher revidieren alte Lehrmeinungen (german)

Named Arguments - Pure Danger (Tech) for Java 7?

2007-08-15T18:23:00.000+01:00

On his blog, Alex Miller is has put up Some comments on D&R’s Java 7 wishlist. One is about Named Arguments:

I have seen no one propose this, but I’ve been thinking for a while that it would be really helpful in situations where you have lots of optional parameters. It would be great for constructor injection, argument passing on a program interface, embedded DSLs/fluent interfaces, etc.

I really like the idea of named arguments, although I'm not sure if they are the best solution for all the things mentioned above: DSLs in Java? Without operator overloading?.

Anyway, it believe they would make Java Code (even more) readable and the usage could prevent mistakes:

Documentation and parameter re-ordering are nice, but it would be really cool to have default values along with them:

However, when does it end? Imagine indexed varargs:

And did I hear critics say "But named methods can simulated with a dedicated bean (having a corresponding property for each method parameter)!"
Well, that would leads to lots of grabage of code (and objects inside the jvm):

Summing up, I think this would be a minor but not less worth language change to consider for Java 7 (or 8). Especially since everything above should be 100% backward compatible and YOU DON'T HAVE TO USE EM!

What do you think: Take it or leave it?

Re: How to write Iterators really REALLY fast (in Java)

2007-07-17T21:39:00.000+01:00

Browsing through the last week entries of my subscriptions, I stumbled across an interesting post entitled "How to write Iterators really REALLY fast". It is about simulating the yield functionality available in C# iterator blocks as of .NET 2.0 - as you might have guessed: it allows to write iterators really fast. =)

The author presents an example featuring a utility class Yielder, which provides the same ease-of-use completely without pre-compilers and keyword overrides/additions. However, the implementation details were not published with it - but promised for next week (as of now 'this' week). Feeling eager how this can be done, I tried implementing the interface based on the descriptions in the text and the mentioned examples (one repeated here for convenience):


public Iterator iterator() {
  return new Yielder() {
    public void yieldNextCore() {
      for (Object nextItem : coll) {
        if (pred.evaluate(nextItem)) {
          yieldReturn(nextItem);
        }
      }
    }
  };
}

However, it turned out that the task was not as easy as I thought. Actually, it took me over one hour to write one and I didn't succeed in making it as efficient as a true "yield".

Probably, the author will soon present a smart solution to the two challenges I encountered:

1. How to create more than one Iterator from a single Yielder instance?

Obviously, yieldReturn is a method of the Yielder class, so it is not (automatically) aware of the a specific Iterator instance. Therefore, I moved the method (along with a yieldBreak equivalent) to an interface which will be passed to the iterator-block (yieldNextCore).

2. How to avoid multiple iterations without an additional collection as storage?

Maybe my intuition is wrong, but the Next in yieldNextCore implies to me that the method will be called repeatedly. Probably until it exits after a yieldBreak call or without one to yieldReturn. Hence, in the example above it would be the number of elements the predicate pred evaluates to true. Taking the worst case: One call for each of the n elements in the collection coll. Ergo the time scale rises from O(n) to O(n^2)!

Anyway, I might be wrong and it is only called once. Thus however, an element passed to yieldReturn has be stored until the corresponding Iterator.next call releases it. In a single threaded environment, the means all of the (predicated) elements since there is no way to suspend the for-loop. This may be practicable for iterations over a few elements. But again, the worst cast the complexity rises from O(n) to O(n^2) - this time in memory consumption!

As a result, the only possible implementation idea I got was utilizing a dedicated thread to execute the iterator-block (yieldNextCore). This can block the iteration while the iterators' method can return. However, it turned out one thread is not enough, since it could "wait forever", if the iteration is not completed. Another had to monitor a weak reference to it. But again, the the problem is that the loop will always be executed, which leads to O(n) even if the iteration is not continued after retrieving the first element.

Inline-Methods and Closure-Blocks

2007-07-07T01:26:00.000+01:00

Yesterday, I browsed once again through Neal Gafter's Blog... It turned out to be a great mistake, as I got an idea which kept floating in my mind almost the whole night and day: A way to abstract loops or other code blocks without closures, but by inlining special methods around them (seems like the inverse of a closure to me).
Still not being 100% convinced by function types, especially their syntax, I tried to write myself: A proposal for extending the Java Language Specification

Actually, I think the idea behind it is great, although the proposal itself might not - I didn't sleep much last night and have/had plenty other things to work, so please forgive the small mistakes in the pseudo code and text. However, if there is interest, I'll try to find the time to revise it. So please let me know what you think about it!
[ Collaborators are welcome - its on Google Docs you know ;-) ]

Abstract:
This proposal shows that it is not necessary to add full blown closures or function types to the Java programming language in order to allow control abstraction.
The main motivation behind it is the agreement, that control abstraction cannot be implement with the current language constructs, such as anonymous classes - only syntactic improvements won't help. On the other side however, there is the fear that the introduction of nameless functions will remove one of the languages strongest points: its readability - raw type sequences everywhere. The proposed solution is to reuse existing syntax and add a single new semantic, which is simple-to-use, (relatively-)simple-to-implement, but yet very powerful. In short, the main idea is to inline special methods surrounding a (closure-)block, which remains in the lexical scope where is called.

Please have a look at the full document.

Usage-Example: Map enhanced for-loop.
(see document for the declaration of 'forEach')

Usage-Example: with a.k.a. closeAfter.
(see document for the declaration of 'with')

Usage-Example: blocked asynchronous reading.
(see document for the declaration of 'readFully')

The Java Memory Model & Concurrency

2007-04-21T13:04:00.000+01:00

I just watched the presentation Advanced Topics in Programming Languages: The Java Memory Model given by Jeremy Manson (Google Tech Talks March 21, 2007). Although I was familiar with most, I really enjoyed watching the complete video (I rarely do this for those longer than 15min). If didn't see it already:

Extended Type-Cast vs. Closures vs. Current Java

2007-04-02T16:39:00.003+01:00

Although I'm not a fan of messing up the Java language, I had another idea, I'd like to share:

An extended type-cast for single-method interfaces, which succeeds if the signatures are compitable. More precise, the target's method could be overridden by the one of the source interface, the syntax could be: (A as B)
(Note: contravariant arguments would be also possible)

I guess it's is highly related to the ongoing debate if and how to integrate closures (CICE, FCM and BGGA). Although, I think the last one has its pros and I really like the idea of first-class methods (place my vote here), the remaining one really has a mighty ally: simplicity.

However, the absense of method/functions type, which can be assigned only depending on their signature types, makes it look a bit clumsy. With the proposed extended type-cast, things would be more balanced as this example shows.

Just, for those who didn't have noticed yet, the main thing is (Bar as Foo), but it looks nicer within the other syntax sugar as well:

calling the single method of an interface, its name can be omitted
simplifyedcreation of anonymous classes, which implement single-method interfaces
usage of var/final instead of specifying the reference type

EDIT: Modified the source to match the BGGA proposal accoringly to Neal Gafter's comment.

A new usage of this() !

2007-03-31T16:13:00.000+01:00

All Java developers know the this()-method, which is used to call a constructor of a class within another one. It is the only Java-method with a return value constrained to the actual class (a.k.a. self-type).

Imagine if we could use the parameterless version (even if there is no such constructor) within a method. As this, it would return a reference of the class, but virtually typed.

What about the benefits?
This simple, but powerful language extension would allow virtual calls to static methods!

Let's take a look at this example.

Without the new this()-method, one would have to override every method calling the static method, which we want to be virtual. Here, one would have to remove all comment to maintain the output:

One: static(0) - virtual(1)
Two: static(0) - virtual(2)

What do you think, is it worth to submit a RFE?
At least no new keyword or anything else have to introduced and the meaning is widely consistent with the constructor.

Car Surfing Advertisement

2007-02-23T22:00:00.000+01:00

Nissan Qashqai looks like a great car, but the advertisement is really awesome:

I guess this kind of recreational sport can get very expensive without a sponsor, remembering my wastage of skateboards in the good old days. :-)

Obvious Facts and the 3 Types of Virgins

2007-02-23T13:26:00.000+01:00

A recent blog entry about a video called Le Grand Content, which examines the omnipresent Powerpoint-culture in search for its philosophical potential, brought me to the website of the creator. Beside that these pages are a great online portfolio IMO, the whole videos there are so f%#$%ing incredibly entertaining - in short: watch'em, now!

obvious facts (Le Grand Content by Clemens Kogler)

the 3 types of virgins (Le Grand Content by Clemens Kogler)

Transmediale.07 and Reactable

2007-02-04T17:40:00.000+01:00

Finally, I made myself attending to the transmediale.07 exhibition at the very last day..

It began great, because two french girls gave me 2 tickets for free :-)
(o.k. I only needed one and that would have cost me 2 bucks, but very nice anyway!)

Afterwards, I found myself waiting in row for almost 25 minutes to see not more than 10 installations. Although I must confess, that I was a bit disappointed in the beginning because of the quantity, but it turned out, I liked more than half. This is is a very good rate IMO, though none was really super spectacular,

The best thing however was later on and beneath: a live demo of another multi-touch and marker sensing table called reactable. Sure not only a great interface for DJing, but the performance was very nice to watch and use (at least the 45 sec I tried)..

Transmediale.07 + Reactable