Since I plan to move to Switzerland, I have decided to improve my knowledge of German. I forgot most of it, since last time I was using it was in high school.

The old times

I remember that it was much easier to learn languages in primary school. There were mostly foreign channels on cable tv, so I could listen to English, German, French and many others. Most of the computer programs and games in the era of C64 were in English or German and actually seeing Polish on computer screen was kind of weird. I have been exposed to foreign languages all the time (as I’ve been watching many cartoons:)).

vs Now

Today there is no single fully German channel on my cable tv. There aren’t many in English either, but I don’t watch cartoons any more. Most games and apps are translated into Polish. The rich media stream of language resources dried out.

But I know that it’s good for me to learn German from all sources I can reach, and not only from textbook. So here I some steps I took to learn it faster and better.

Getting a dictionary

First of all I bought myself a dictionary. There’s nothing more important than a small book that I can carry with me. When I use a dictionary I can look at words at the same page, find similarities, patterns, find new words and meanings. I can check if words similar in Polish are also similar in German and I can learn how words are created. My dictionary is always close to me.

Language course

Much to my surprise, all language courses are scheduled for one year and start in September or October. There are some super expensive one month fast paced courses for businessmen, but I’m not a businessman. There are also some during summer, but it’s still couple months I don’t want to waste.
That didn’t discourage me from taking a course – online. I have found fantastic materials at the Deutsche Welle site (www.dw.de). They were prepared together with people from Goethe Institut. That means this is a really good material. There are several courses available for different levels. You can also learn Polish there:) You can take a course in your language, there are German courses in many languages. They have really done a good job. I enjoy learning from these pages. When I found this page, I immediately pinned it as an app in my firefox as I visit it very often.

Television

Well, I thought that since Polish tv stations offer a VOD with their programs, maybe also I could find German television over internet. And there are many stations that you can watch for free. I will post links later since I haven’t saved them after my search. What I found difficult when I watch tv shows is kind of lack of context. It’s difficult to only see and hear and have no idea what is actually going on. I find watching DVDs much more helpful.

DVDs

I was surprised with that, but watching a movie in English with German subtitles is just great. On my trip to Zurich in March, I watched like that several movies and bought some DVDs to watch at home. Usually first I watch movie in English with German subtitles. I get the contexts, the plot and connect the subtitles to scenes. Then I watch the movie in German with German subtitles. I don’t understand everything, but I learn pronunciation, note interesting words, I can follow the plot and I find the movie entertaining instead of being lost.

Computer

As mentioned earlier, 20 years ago all apps and games were in English and German. I thought that least I can do, I can change the language of my operating system to German. Of course I can’t do that with Windows, but I don’t use it often.
In Ubuntu I just installed the language and put it first on priority list. To my surprise after restart not only my system was in German, but all the applications too! That’s awesome – first of all thanks to Ubuntu developers it’s very simple, second – I don’t have to install anything from the beginning, it just works. Also many web search results appear in German, that’s great! It was 5 minutes of work that put me in the middle of German language. I will be honest with you. I was to partition my disk in laptop to give some more space to Ubuntu. I freaked out when I saw gparted in German. I’m not in that league yet. Fortunately it’s super easy to start an application in different language. In the console:

LANGUAGE=en gparted

And that’s it. Gparted starts in English if you have English installed. I still shake my head surprised that it is so simple and works so well.

Ok, that’s it for today. I will publish few more points on my approach soon.

When I moved to git (on my laptop only), I had in mind all steps that that lead from first commit to fix a bug, to deployment on production. And I wondered whether it is applicable to git repositories. I have found really nice git branching model: Git Flow. I can see it is popular and basically isn’t very different from what we have been using. What I really like about it is that it uses branches a lot. They are so light in git, that using them is almost seamless. All the pain caused by svn’s slow checkout, branching and merging is cured.

Today creating a branch is first thing I do when I develop some new code for my project. Having a branch lets me commit early and often without messing with what’s already working. I wouldn’t mind if Intellij commited a file when I press Ctrl+s, although that could look scary in the repo’s log:) Until it’s done, I use Ctrl+k often.

Anyway, the Git Flow model is based on central repository. I wonder if there’s a distributed release model for dvcs.

Knowing exact position of the superhero would ease removal of the border, but looking for it might be painful. Fortunately someone before me had this problem. There are actually several methods to remove excess of pixels. The one I used is the trim method.

convert supertapir.jpg -trim tapir-trim-sample01.jpg

And the result

is not exactly what I expected. The border recognition needs to be a bit more tolerant to color changes and you can control it with -fuzz parameter.

convert supertapir.jpg -fuzz 5% -trim tapir-trim-sample02.jpg

Fanfares! Works like a charm.

sudo apt-get install imagemagick

It has plenty of options and they just pop up when I need them. After manually aligning set of images in Libre Office, finding out that single command can do it really impressed me. I can see many one-liners in my life.

So, having several images:

img00.jpg
img01.jpg
...
img99.jpg

All you need to do is pick a good name for your pdf

convert img*.jpg images.pdf

I expected imagemagick to be able to batch convert images and crop or resize them.

convert img*.jpg -resize 50% img-small%d.jpg

Where %d will be replaced with processed file number.
But more time we spend together, more powerful it looks.

 PS&#92;_GIT&#92;_PART=&quot;(git branch 2&gt;/dev/null | grep -e '&#92;* ' | sed 's/^..&#92;(.<em>&#92;)/{&#92;1|/'; git status | grep -c -e '#.</em>&#92;(modified&#92;|new file&#92;|deleted&#92;):' | sed 's/&#92;(.*&#92;)/&#92;1}/') | sed '$!N;s:&#92;&#92;&#92;n::' &quot; 

Ok, I agree that it’s write only:) It should be in one line in .bashrc. Now last thing is to make it part of your PS1. Like this

 PS1="... \$($PS\_GIT\_PART) ..." 

And now my prompt looks like this:

 bibix@sputnik:~{master|1}$ 

There’s no need now to check branch or status every time I change directory to some git repo.

IT IS AWESOME

Until I started using it, I was thinking that dynamic typing is just a hidden cost of all the features I get with Groovy. Errors at run-time were painful, but I quickly learned the patterns to follow when developing dynamically typed code.

With Scala I found out that static typing can be used together with all those higher order functions, functional programming etc. And it makes me much more comfortable.

I approached Scala the usual way. I solved first problem from Project Euler. It worked fine, but I didn’t like the style. There was too much Java in my Scala code and I knew it can look better, more functional. And the only functional language I had been using so far was Haskell.
So, I took a Haskell tutorial from and started to look for similarities in Scala. Rewriting Project Euler’s solutions in functional style was a lot of fun and training for my brain. Now it’s more natural.

Since I posted solution for the Problem 024 in Groovy. Here’s one in Scala:

object Problem024 extends App {
  val nums = (0 until 10).toList.permutations
  val result = nums drop(999999) next() map(_.toString) reduce(_+_)
  Console.println(result)
}

It’s a simple bruteforce. What is beautiful about it? The List.permutations method returns Iterator. In Groovy similar method returns a Set which makes it almost useless. There’s an alternative method in Groovy Collection.eachPermutation, but it takes a closure as a parameter. The third option is using PermutationGenerator which returns an Iterator, which I didn’t know of two years ago.

What I see is that Scala’s type system is really well thought. If there are or were any glitches, they were quickly fixed (from small version to small version). It’s not four two years development cycle like in case of Java.

So far, I’ve solved more than 40 problems in Project Euler. You can see sources at https://github.com/bibix/euler. And many of them are one-liners thanks to Scala.

And you can always follow me on Twitter

// in build.gradle
apply from: "libraries.gradle"
apply from: "subprojectsTasks.gradle"

// in libraries.gradle
versions = [
  abc: "1.6"
]

libraries = [
  abc: "org.abc:abc:${versions.abc}"
]

// in subprojetsTasks.gradle
subprojects {
  apply plugin:"java"

  dependencies {
    compile libraries.abc
  }
}

And that’s it. You can safely split your build file into logical parts.

Let’s see a sample configuration:

// def versions would create script local variable
versions = [
        camel: "2.5.0"
]

libraries = [
        camel: [group:"org.apache.camel", name:"camel-core", version:versions.camel],
        camelBindy: "org.apache.camel:camel-bindy:${versions.camel}"
]

You can see two maps actually: versions and variables.
First one defines versions used for particular libraries. Since camel version is used in multiple places, you can just extract it and keep outside the libraries definitions.
Libraries is a map of our dependencies.

Usage is also simple:

// somewhere in root project or subprojects
dependencies {
  compile libraries.camel
  compile libraries.camelBindy
}

- awesome-project-root
-- build.gradle
-- settings.gradle
-+ persistence
---- build.gradle
-+ processing
---- build.gradle

Next thing is to add to settings.gradle several lines with subprojects:

include "persistence"
include "processing"

Since now you have 3 build.gradle files in your repository. They are configured as subprojects. You may read more about subprojects in gradle’s documentation. It may be confusing when your projects grows up and you’ll have more of them.

Really nice thing I’ve found in hibernate’s configuration (see https://github.com/hibernate/hibernate-core), is renaming of all these build.gradle files.

rootProject.children.each { project ->
    project.buildFileName = "${project.name}.gradle"
    assert project.projectDir.isDirectory()
    assert project.buildFile.isFile()
}

This little code snippet lets gradle know that your project’s structure will be:

awesome-project-root
-- build.gradle
-- settings.gradle
-+ persistence
---- persistence.gradle
-+ processing
---- processing.gradle

And this really simplifies navigation. I think it’d be nice if gradle supported both naming conventions.

I have found a site about shortcomings of the visitor pattern.
The proposed solution in Nice programming language are, so called, multimethods.
I asked myself if I could use similar solution in groovy. The answer is yes, fortunately. Multimethods (or multiple dispatch) can be used in groovy.

In groovy you don’t have to implement visitor pattern and extend your domain objects. The following code will work just as you would expect:

// Base class
class Feature {
    String name

    public String toString() {
        return "Feature{" +
                "name='" + name + '\'' +
                '}';
    }
}

class BooleanFeature extends Feature{
    boolean value

    public String toString() {
        return "BooleanFeature{" +
                "value=" + value +
                '}';
    }
}

class StringFeature extends Feature{
    String value

    public String toString() {
        return "StringFeature{" +
                "value='" + value + '\'' +
                '}';
    }
}

// Class that processes Feature and its descendants
class Multimethod {
    def printFeature(Feature feature) {
        println "printFeature: $feature"
    }

    def printFeature(BooleanFeature feature) {
        println "printBooleanFeature: $feature"
    }

    def printFeature(StringFeature feature) {
        println "printStringFeature: $feature"
    }
}

Feature feature = new Feature(name:'feature')
Feature booleanFeature = new BooleanFeature(name:'booleanFeature', value:true)
Feature stringFeature = new StringFeature(name:'stringFeature', value:'Hello world')
List<Feature> features = [feature, booleanFeature, stringFeature, otherFeature]

Multimethod multimethod = new Multimethod()

features.each { multimethod.printFeature it}

The output is:

printFeature: Feature{name='feature'}
printBooleanFeature: BooleanFeature{value=true}
printStringFeature: StringFeature{value='Hello world'}

You can see the Feature class and some simple hierarchy. They represent domain classes. The Multimethod class is our processor. It would have to be a Visitor in java, in order to correctly process the collection of Feature elements. It’s not the case in groovy, as it dynamically resolves the type of parameters during runtime.

It saves a lot of coding. Now there’s no need to create class hierarchy only to process a collection properly. This also means, that there’s no need to overload a method for all classes that extend the Feature class.