The flow

I recently came across Node-RED and wondered how good it would be as a tool to automate a few things I find more and more annoying to do manually. A friend of mine challenged me to use it to tweet “positive” posts from Hacker News (mostly because there was a sentiment analysis node as part of the built-in set of nodes). Extra points for making it without code (even though there is a function node to write arbitrary javascript to process messages).

Here is the result:

It works as follows:

• Parse HN's RSS feed creates a new message (Node-RED’s unit of processing) every time a new post appears in HN’s RSS feed.
• limit 5 msg/s ensures that no more that no more than 5 messages per second go through the rest of the flow. HackerNews seems to dislike too frequent requests, as made in the comment fetching node
• delay 1 hour gives some time for the comments to appear
• fetch comments requests the comment web page of the post
• keep text only extracts the comments from the web page
• join merges all the comments into one text
• sentiment analyses the text
• positive only lets only messages with a positive score through
• title > 120 chars ? switches messages depending on whether the title of the post is longer than 120 characters
• truncate title shortens the long title
• long title produces a tweet with the shortened title (adding suspension mark) and the url of the post
• short title simply produces a tweet with the title and the url of the post
• Tweet publishes the tweet on @hackergoodnews.

The sentiment analysis is very simple : it uses the AFINN word list where words or phrases have been manually evaluated between -5 and 5. For example, “you’re a terrific fascist” has a (positive) score of 2 points, because terific is worth 4, and fascist -2… Well, I said it’s simple, not perfect (and to be honest, I browsed the list for a while to find this example ;) )

As a more honest example, here are the 5 most negative posts of last week-end:

1. Reflecting on One Very, Very Strange Year at Uber (score: -117)
2. Uber Investigating Sexual Harassment Claims by Ex-Employee (score: -77)
3. Fukishima is Worse than Ever (score: -60)
4. Uber launches ‘urgent investigation’ into sexual harassment claims (score :-59)
5. The Age of Rudeness (score: -48)

And here are the 5 most positive posts:

1. I started a one-man biz that’s beating VC-backed startups (score: 615)
2. Ask HN: Non-technical readers of HN, why are you here? (score: 273)
3. ReactOS 0.4.4 Released (score: 231)
4. Let’s not demonize driving, just stop subsidizing it (score: 175)
5. Firefox 57 as the first release where only WebExtensions will be supported (score: 127)

Conclusion

Node-RED makes it really easy to build a tweeting bot that ignores sexual harassment and nuclear disasters without even coding (of course, that relies on a sane community commenting the news).

The only shortcoming I found concerns the feed parser which does not remember what was already processed. For example, if I were to restart my Node-RED instance, all the positive posts of the home page would be sent to twitter. That’s not a problem since Twitter detects and rejects duplicate statuses, but it would be more annoying if the messages were sent by email.

However, another (and maybe the biggest) strength of Node-RED is how easy it is to extend it by writing new nodes (with code, this time). That brings two solutions to my “problem”: either use one of the many existing nodes to hack some persistence into the feed parser (e.g. with a database node or a file node), or write my own feed parser. Good times ahead ! :)

Comments

Let’s see if the discussion of this article on HN will be positive ;)

Appendix

Here is the flow to import into Node-RED, if you want to tinker with it:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257

[
    {
        "id": "f24d4456.2acf58",
        "type": "feedparse",
        "z": "47e2e162.19bab8",
        "name": "Parse HN's RSS feed",
        "url": "https://news.ycombinator.com/rss",
        "interval": "1",
        "x": 346,
        "y": 222,
        "wires": [
            [
                "bbbfef8e.5229b8"
            ]
        ]
    },
    {
        "id": "194d8318.d5c7ad",
        "type": "http request",
        "z": "47e2e162.19bab8",
        "name": "fetch comments",
        "method": "GET",
        "ret": "txt",
        "url": "}",
        "tls": "",
        "x": 628.875,
        "y": 314.5,
        "wires": [
            [
                "8f2f189a.7c4f38"
            ]
        ]
    },
    {
        "id": "8feccdd1.b5b48",
        "type": "sentiment",
        "z": "47e2e162.19bab8",
        "name": "",
        "x": 311.125,
        "y": 522,
        "wires": [
            [
                "9fe15e58.b67db"
            ]
        ]
    },
    {
        "id": "8f2f189a.7c4f38",
        "type": "html",
        "z": "47e2e162.19bab8",
        "name": "keep text only",
        "tag": "div.comment span",
        "ret": "text",
        "as": "single",
        "x": 327.5,
        "y": 428,
        "wires": [
            [
                "24ff4198.fca71e"
            ]
        ]
    },
    {
        "id": "24ff4198.fca71e",
        "type": "join",
        "z": "47e2e162.19bab8",
        "name": "",
        "mode": "custom",
        "build": "string",
        "property": "payload",
        "propertyType": "msg",
        "key": "topic",
        "joiner": "\\n",
        "timeout": "",
        "count": "1",
        "x": 480.5,
        "y": 428,
        "wires": [
            [
                "8feccdd1.b5b48"
            ]
        ]
    },
    {
        "id": "9fe15e58.b67db",
        "type": "switch",
        "z": "47e2e162.19bab8",
        "name": "positive only",
        "property": "sentiment.score",
        "propertyType": "msg",
        "rules": [
            {
                "t": "gt",
                "v": "0",
                "vt": "num"
            }
        ],
        "checkall": "true",
        "outputs": 1,
        "x": 470.5,
        "y": 522,
        "wires": [
            [
                "a6426eab.664338"
            ]
        ]
    },
    {
        "id": "a62ee7eb.16d048",
        "type": "template",
        "z": "47e2e162.19bab8",
        "name": "short title",
        "field": "payload",
        "fieldType": "msg",
        "format": "handlebars",
        "syntax": "mustache",
        "template": "} }",
        "x": 686.5,
        "y": 654,
        "wires": [
            [
                "4c2dc9df.bb824"
            ]
        ]
    },
    {
        "id": "a6426eab.664338",
        "type": "switch",
        "z": "47e2e162.19bab8",
        "name": "title > 120 chars ?",
        "property": "article.title.length",
        "propertyType": "msg",
        "rules": [
            {
                "t": "gt",
                "v": "120",
                "vt": "num"
            },
            {
                "t": "else"
            }
        ],
        "checkall": "true",
        "outputs": 2,
        "x": 337.5,
        "y": 625,
        "wires": [
            [
                "fa7acd8f.799d68"
            ],
            [
                "a62ee7eb.16d048"
            ]
        ]
    },
    {
        "id": "da4cb6f0.97bfc8",
        "type": "template",
        "z": "47e2e162.19bab8",
        "name": "long title",
        "field": "payload",
        "fieldType": "msg",
        "format": "handlebars",
        "syntax": "mustache",
        "template": "}... }",
        "x": 688,
        "y": 605,
        "wires": [
            [
                "4c2dc9df.bb824"
            ]
        ]
    },
    {
        "id": "fa7acd8f.799d68",
        "type": "change",
        "z": "47e2e162.19bab8",
        "name": "truncate title",
        "rules": [
            {
                "t": "set",
                "p": "article.title",
                "pt": "msg",
                "to": "$substring(msg.article.title, 0, 120)",
                "tot": "jsonata"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 537,
        "y": 605,
        "wires": [
            [
                "da4cb6f0.97bfc8"
            ]
        ]
    },
    {
        "id": "bbbfef8e.5229b8",
        "type": "delay",
        "z": "47e2e162.19bab8",
        "name": "",
        "pauseType": "rate",
        "timeout": "5",
        "timeoutUnits": "seconds",
        "rate": "5",
        "nbRateUnits": "1",
        "rateUnits": "second",
        "randomFirst": "100",
        "randomLast": "500",
        "randomUnits": "milliseconds",
        "drop": false,
        "x": 314.5,
        "y": 315,
        "wires": [
            [
                "536603f7.dd90c4"
            ]
        ]
    },
    {
        "id": "536603f7.dd90c4",
        "type": "delay",
        "z": "47e2e162.19bab8",
        "name": "",
        "pauseType": "delay",
        "timeout": "1",
        "timeoutUnits": "hours",
        "rate": "1",
        "nbRateUnits": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "drop": false,
        "x": 464.5,
        "y": 315,
        "wires": [
            [
                "194d8318.d5c7ad"
            ]
        ]
    },
    {
        "id": "4c2dc9df.bb824",
        "type": "twitter out",
        "z": "47e2e162.19bab8",
        "twitter": "",
        "name": "Tweet",
        "x": 846.5,
        "y": 628,
        "wires": []
    }
]

Every day brings a new flavour of 2048 to Hacker News. After the AI version and the multiplayer version, I propose the Augmented Reality version.

You can try the live demo in your browser.

How to play (the longer version)

To play the augmented reality version:

• Go to the live demo with Firefox or Chrome. Apparently Opera is also able to use the webcam. Forget Safari and IE… you weren’t seriously considering, were you ?

• Share the webcam with the webpage. You can stay in your underwear, I swear I don’t upload any data.

• Print the image of the tag at http://goo.gl/GWdcT2) or display it on your phone if you don’t have a printer. Here is a qr-code that links to the tag, if you feel more like scanning it than typing the address.

• Show the tag to make the game appear. Tilt it to make the tiles slide in one way or the other (up, down, right, left). See illustrations below.

How to play (the illustrated version)

Controling an HTML5 game with pieces of paper is not exactly mainstream, so I will illustrate the interaction with pictures.

1. Show the printed tag to the webcam:

Or the digital version of the tag:

The game should replace the image of the tag:

Tilt the tag/game up to send the number tiles up:

Tilt the tag/game left to send the number tiles left:

That’s it!

Shortcomings

The nice animations of the original 2048 are gone, because the game board is transformed into a canvas texture to display in the 3D scene. Another solution would be to transform the game board using CSS 3D transforms, and overlay it on the video… I may keep this for another afternoon hack.

Hire me!

If you need some help on a similar project, do not hesitate to contact me !

Yes, I’m bad. You can try to do better on the live demo. You will need to print (or display on your favourite device) this tag. The demo needs to access your webcam via the getUserMedia/Stream API, which means it works only on Firefox, Chrome and Opera. It should work on their mobile versions though. Firefox has the best performances, thanks to the asm.js optimisations.

How does it work ?

When Chilitag number 8 (why 8? no idea) is detected, the bird flaps. If the tag was continuously detected, the bird would take off like a rocket, so users naturally make flapping movements with their hand. This has been observed in 100% of the users at the time of this writing (I was alone).

Why did you do that ?

It’s fun, and I needed an excuse to toy with chilitags.js.

OK fine, I also hope this will get someone interested in hiring me to do similarly fun stuff.

Credits

This demo is based on Heavy Bird. By based, I mean I only added a quick and dirty hack.

Comments

I posted this article on HackerNews, if you care to comment.

Introduction

Promoting Chilitags, our C++ library for detecting fiducial markers, from “research code” to published code means that we have no excuse any more for not having any test at all. After a short comparisons for testing frameworks, it seemed that Google Test would best fit our need.

Chilitags is heavily based on OpenCV. It turns out that OpenCV already integrates Google Test, and adds their own features, so you don’t have to write a function to assert that two matrices are equal for example. I’m more and more conviced that “OpenCV” means “we already did everything you may and will need” in some secret language.

However, I failed to find documentation on OpenCV’s ts module, even though they use it to test all the other modules. It is not listed in OpenCV’s documentation, and Google didn’t help either. I asked on StackOverflow how to use OpenCV’s test framework with CMake, but haven’t received an answer. This post aims at answering myself the question with what I found.

First, I’ll show how to configure CMake to compile an OpenCV’s executable, and then explain how to run several of them as part of CMake’s tests.

Compiling an OpenCV test executable

This section gives a minimal example of an OpenCV based library being tested by the OpenCV test framework. We give the code of a dummy library, short test codes, and the CMake set up to build them all.

The code to be tested

Let’s say we want to test a dummy library, whose interface is declared in mylib.hpp:

1
2
3
4
5
6
7
8
9
10

#ifndef mylib_hpp
#define mylib_hpp

#include <opencv2/core/core.hpp>

namespace mylib {
  void myfunction (cv::InputOutputArray myparam);
}

#endif

and implemented in mylib.cpp:

1
2
3
4
5

#include <mylib.hpp>

void mylib::myfunction (cv::InputOutputArray myparam) {
  myparam.getMat() = cv::Scalar::all(0);
}

Right… Obviously, this library is not the focus of this article.

The test code

We first write a simple test case in mytest.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <opencv2/ts/ts.hpp>
#include <mylib.hpp>

class MyTestClass : public cvtest::BaseTest
{
public:
    MyTestClass(): mat(cv::Scalar::all(1)){}

protected:
    cv::Mat mat;

    void run(int) {
      ts->set_failed_test_info(cvtest::TS::OK);

      //check that all values are between 1 and 1 (and not Nan)
      if (0 != cvtest::check(mat, 1, 1, 0) )
          ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);

      mylib::myfunction(mat);
      
      //check that all values are between 0 and 0 (and not Nan)
      if (0 != cvtest::check(mat, 0, 0, 0) )
          ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
  }
};

TEST(MyTestSuite, ATestThatPasses) {
  MyTestClass myTestClass;
  myTestClass.safe_run();
}

TEST(MyTestSuite, ATestThatFails) {
  bool mybool = false;
  ASSERT_TRUE(mybool);
}

This test cases will be automagically run in a specified folder if they are compiled with such test_main.cpp:

1
2
3

#include <opencv2/ts/ts.hpp>

CV_TEST_MAIN(".")

That’s it!

Structure and CMake Files

All these files will be structured typically as follow:

1
2
3
4
5
6
7
8
9
10
11
12

mylib/
  CMakeLists.txt
  lib/
      CMakeLists.txt
      include/
          mylib.hpp
      src/
          mylib.cpp
  test/
      CMakeLists.txt
      mytest.cpp
      test_main.cpp

The general CMakeLists is standard…

1
2
3
4
5
6
7
8
9
10
11
12
13

cmake_minimum_required(VERSION 2.6)

project(mylib)

include_directories(lib/include)

add_subdirectory(lib)

option (WITH_TESTS "build tests" ON)

if (WITH_TESTS)
  add_subdirectory(test)
endif()

…and so is the one to compile the library (in src/CMakeLists.txt):

1
2
3
4
5

file(GLOB_RECURSE mylib_source src/*)
add_library(mylib SHARED ${mylib_source})

find_package(OpenCV REQUIRED core)
target_link_libraries(mylib ${OpenCV_LIBS})

Last but not least, it is not much more complicated to compile an OpenCV test:

1
2
3
4
5
6
7

file(GLOB mytest_source_files *.cpp)
add_executable(mytest ${mytest_source_files})

target_link_libraries(mytest mylib)

find_package( OpenCV REQUIRED ts)
target_link_libraries( mytest ${OpenCV_LIBS} )

And we’re done.

Running the tests

Finally we can compile averything and run the test in a standard CMake process. Here is the one if you use Makefile:

1
2
3
4

mkdir build
cd build
cmake ..
make

This creates a mytest executable in build/test which can be run to produce this output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

[==========] Running 2 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 2 tests from MyTestSuite
[ RUN      ] MyTestSuite.ATestThatPasses
[       OK ] MyTestSuite.ATestThatPasses (0 ms)
[ RUN      ] MyTestSuite.ATestThatFails
pathto/opencv/test/mytest.cpp:34: Failure
Value of: mybool
  Actual: false
Expected: true
[  FAILED  ] MyTestSuite.ATestThatFails (0 ms)
[----------] 2 tests from MyTestSuite (1 ms total)

[----------] Global test environment tear-down
[==========] 2 tests from 1 test case ran. (1 ms total)
[  PASSED  ] 1 test.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] MyTestSuite.ATestThatFails

 1 FAILED TEST

Yay!

Configuring CMake to run the tests

Now we may want to use several test executables for various reason. For example, we may want to split unrelated test, or split a test that takes too long to run, or make another kind of test (unit tests, performances tests, internationalisation tests or what not), or simply run non C++ executable.

It would be a bit cumbersome to launch them all by hand, especially when CMake integrates testing facilites.

Instead, we simply tell CMake which programs are test programs by adding an enable_testing() directive to the general CMakeLists:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

cmake_minimum_required(VERSION 2.6)

project(mylib)

include_directories(lib/include)

add_subdirectory(lib)

option (WITH_TESTS "build tests" ON)

if (WITH_TESTS)
  enable_testing()
  add_subdirectory(test)
endif()

We also specify an add_test(testname executablename) directive for each test executable:

1
2
3
4
5
6
7
8
9

file(GLOB mytest_source_files *.cpp)
add_executable(mytest ${mytest_source_files})

target_link_libraries(mytest mylib)

find_package( OpenCV REQUIRED ts)
target_link_libraries( mytest ${OpenCV_LIBS} )

add_test(mycmaketest mytest)

This way, CMake will create a test target which can be built by your IDE to run the tests. For example when I run make test, I get the following output:

1
2
3
4
5
6
7
8
9
10
11
12

Running tests...
Test project pathto/build
    Start 1: mycmaketest
1/1 Test #1: mycmaketest ......................***Failed    0.00 sec

0% tests passed, 1 tests failed out of 1

Total Test time (real) =   0.01 sec

The following tests FAILED:
    1 - mycmaketest (Failed)
Errors while running CTest

This output is a lot less detailed than the previous one, which makes sense if there are a lot of tests happing, There is also an option to display the output of each test program (as shown before). With make, it’s make test ARGS=-V.

Conclusion

Of course, there is much more to say about CMake’s test facilities or OpenCV’s test framework, not to mention the embedded Google Test framework. While the documentation for the former and the latter can be found easily, I have yet to find the documentation for OpenCV’s ts module. As an alternative, I guess I’ll stick to reading the source of the module, and look at the examples in the test folders of the other modules.

Do not hesitate to comment on the StackOverflow question if you know more !

The Story Behind the Story

I tried to explain how this piece of code found that (1+2)!! + 3!^4 - 5 = 2011, but C++ is not famous for being concise and transparent. So I tried to give the general idea, and gave the full source in one block, but it was not very satisfying. Full of remorse, I’m now writing this post about how I should have written the previous post, so I can sleep at night again.

I’ll get some inspiration from literate programming, which I’ll quickly present. Then I’ll show how it could have been used on the previous post. This method won’t work for any language, so I will present another one, based on a pending addition to Jekyll.

Literate Programming

Let me copy-paste the definition from the Wikipedia article about literate programming for you:

The literate programming paradigm, as conceived by Knuth, represents a move away from writing programs in the manner and order imposed by the computer, and instead enables programmers to develop programs in the order demanded by the logic and flow of their thoughts.

Basically, the documentation and the code is written in the same file, but in the order of the natural speech, not in the order expected by the compiler/interpreter, unlike javadoc-alike systems. A preprocessor will extract the code, and reassemble it in the order expected by the compiler/interpreter (hereafter: the processor).

In order to show to the processor that we are serious about not caring about him, literate programming can be done with latex, or a word processor. Yes, I spent an internship coding (Spec#) within Word, and yes, I actually enjoyed it. More recently I discovered Sweave which makes statistical exploration with R enjoyable (for a programmer).

Of course, the rule that any idea has already been implemented (better) and published also applies to literate programming with Markdown (Markdown being the notation used to format this article). In this case, a script comments out all the text that is not marked as code. I guess the author calls this “lightweight literate programming” because the code still has to be written in the order expected by the processor.

Manual Literate Programming On GitHub’s Jekyll

The idea here is to use the #include directive of the C/C++ preprocessor along with the {% include %} tag of the Liquid Extensions of Jekyll to build the “interconnected ‘webs’ of macros” of Knuth’s vision of literate programming. The extraction step is manual: each macro will be written in a separate file.

For example, the core search function seems complicated at first:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

template <bool ALL, int VERBOSITY>
void search(Number expectation, const Number epsilon = 0.1) {
  EvaluationResult result;
  long tRemaingCandidates = factorial[NBINOPERATIONS]
                    *pow(NBINOPERATIONTYPES,NBINOPERATIONS)
                    *pow(MAXFRAC+1,NBINOPERATIONS+NOPERANDS-2)
                    *pow(MAXSQRT+1,NBINOPERATIONS+NOPERANDS-1);
  std::cout << tRemaingCandidates << " candidates" << std::endl;
  do {
      result = evaluateCandidate(expectation, epsilon);
      if (result & VERBOSITY) {
          std::cout << decode(result) << ": ";
          printCandidate();
      }

      --tRemaingCandidates;
      if (ALL && !(tRemaingCandidates%100000000)) {
          std::cout << tRemaingCandidates << " remaining candidates"
                  << std::endl;
      }
  } while (generateNextCandidate() && (ALL || result != CORRECT));
}

Actually it is very simple if we extract the code related to printing progress:

1
2
3
4
5
6
7
8
9
10
11
12
13

#include "a-lot-of-code-before.inc"

template <bool ALL, int VERBOSITY>
void search(Number expectation, const Number epsilon = 0.1) {
  EvaluationResult result;
  #include "print-candidate-total.inc"
  do {
      result = evaluateCandidate(expectation, epsilon);
      #include "print-progress.inc"
  } while (generateNextCandidate() && (ALL || result != CORRECT));
}

#include "a-lot-of-code-after.inc"

We can detail separately the formula of the total of candidates, by showing only the content of print-candidate-total.inc:

1
2
3
4
5

long tRemaingCandidates = factorial[NBINOPERATIONS]
                *pow(NBINOPERATIONTYPES,NBINOPERATIONS)
                *pow(MAXFRAC+1,NBINOPERATIONS+NOPERANDS-2)
                *pow(MAXSQRT+1,NBINOPERATIONS+NOPERANDS-1);
std::cout << tRemaingCandidates << " candidates" << std::endl;

And we don’t even need to show the content of print-progress.inc, because it is just uninteresting print instructions.

The Markdown document becomes something like:

1
2
3
4
5
6
7
8
9
10

The core method is pretty simple; generate a solution and try the next:
{% highlight cpp %}
{% include 2011-12-18/search.cpp %}
{% endhighlight %}

Blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah,
which gives us `(n-1)! * k^n * (s+1)^(n+n-1) * (f+1)^(n+n-1)` candidates: 
{% highlight cpp %}
{% include 2011-12-18/print-candidate-total.inc %}
{% endhighlight %}

This Markdown document is describing how to write a Markdown document describing other files by including them… Way too meta for me. If you too need to lower down the abstraction, you can have a look at the files I’m talking about:

• explanation.markdown is the article describing how the program works
• search.cpp and print-candidate-total.inc are pieces of code explained in the article.
• print-progress.inc, a-lot-of-code-before.inc, and a-lot-of-code-after.inc is the rest of the code.

The whole point of all this is that the code remains compilable (e.g. with g++ -o search search.cpp) without any transformation, just like the monolithic main.cpp, but the explanation can be a lot more clear. It also means that there is no need to propagate modifications into the description should the code changes or vice versa.

Reverse Literate Programming on Github’s Jekyll

Now the problem is that a lot of programming languages are too elegant to dirty their parsing hands with the include of a preprocessor. Of course, most languages allow the import of some notion of modules, but it’s just the processor trying to dictate us the order in which to describe a program again.

Without heavy weaponry like a real literate programming preprocessor, we will have to call a truce. We’ll still write the code in the order of the processor, but explain it in a human order. Anyway, no one actually believed that I wrote the code of previous section in the presented order.

Instead of writing a story that will be transformed into a program, we will write a program that will be reassembled into a story – hence the reverse literate programming. The feature needed here is to be able to extract parts of the source code. Jekyll’s {% include %} can only extract the whole, but if this patch makes it through, we will be able to use blocks like:

1
2
3
4

{% extract source.file %}
  {% after //Some marker %}
  {% before //Some other marker %}
{% endextract %}

Where:

• source.file is the source to include (similarly to the {% include %} tag already in Jekyll),
• after is a tag to specify the line after which the content of the file should be included,
• before is a tag to specify the first line from which the content of the file will be ignored again.

Example

For example, if I were to document the code of patch, instead of including the whole file containing:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

module Jekyll

  class ExtractBlock < Liquid::Block

    def unknown_tag(name, content, tokens)
      case name
      when "after"
        @after = content.strip
      when "before"
        @before = content.strip
      else
        super
      end
    end

    def initialize(tag_name, file, tokens)
      super
      @file = file.strip
    end

    def render(context)
      includes_dir = File.join(context.registers[:site].source, '_includes')

      if File.symlink?(includes_dir)
        return "Includes directory '#{includes_dir}' cannot be a symlink"
      end

      if @file !~ /^[a-zA-Z0-9_\/\.-]+$/ || @file =~ /\.\// || @file =~ /\/\./
        return "Include file '#{@file}' contains invalid characters or sequences"
      end

      Dir.chdir(includes_dir) do
        choices = Dir['**/*'].reject { |x| File.symlink?(x) }
        if choices.include?(@file)
          source = File.read(@file)
          #Preceding code is the same as IncludeTag.render
          matchdata = source.match /#{Regexp.escape(@after)}[^\n]*\n(.*)\n.*#{Regexp.escape(@before)}/m
          if matchdata.nil? or matchdata.size < 2
            return "Unable to determine which lines of '#{@file}' "+
            " are between '#{@after}' and '#{@before}'"
          end
          source = matchdata[1]
          #Following code is the same as IncludeTag.render
          partial = Liquid::Template.parse(source)
          context.stack do
            partial.render(context)
          end
        else
          "Included file '#{@file}' not found in _includes directory"
        end
      end
    end
  end

end

Liquid::Template.register_tag('extract', Jekyll::ExtractBlock)

I could simply write a markdown file containing:

1
2
3
4
5
6

Blablabla, I just copy-pasted `include.rb` and added this processing to the
content read from the file:
{% extract extract.rb %}
  {% after #Preceding code is the same as IncludeTag.render %}
  {% before #Following code is the same as IncludeTag.render %}
{% endextract %}

Which would give:

Blablabla, I just copy-pasted include.rb and added this processing to the content read from the file:

1
2
3
4
5
6

          matchdata = source.match /#{Regexp.escape(@after)}[^\n]*\n(.*)\n.*#{Regexp.escape(@before)}/m
          if matchdata.nil? or matchdata.size < 2
            return "Unable to determine which lines of '#{@file}' "+
            " are between '#{@after}' and '#{@before}'"
          end
          source = matchdata[1]

Alternatives

I can think of two other ways to specify the part of the file to be included. First, specifying the numbers of the first and last line to keep would be the easiest, but it would mean that the documentation has to be updated each time the file changes.

Second, the a from/until pair could specify border lines similarly to the after/before pair, except that the content would include these two lines. The problem here is that premature truncations could happen if we want to stop the inclusion on lines such as } or end.

In the end, the only assumption in the after/before pair is that one can add lines only for the sake of documentation, but I have not seen a programming langage which does not allow comments, so it is always possible to delimit regions.

The story

The Fondation Cartier in Paris created an exhibition called Mathematics – A Beautiful Elsewhere and invited mathematicians and artists. Among them, Takeshi Kitano proposed a game called “La réponse est 2011” (The answer is 2011). The rules are simple:

• The player can use the as many number as needed, but in the natural order: 1, 2, 3, 4, 5, etc.
• These numbers can be the operands of +, -, *, /, ^ (power), ! (factorial), and square root. Parenthesis can be added freely to order these operations.
• The result should be 2011, and the formula should use as few numbers as possible.

Takeshi Kitano proposed several answers, the shortest being:

(1+2+3)^4 + (5*6*7*8) – (9*10*11) + 12 + 13 = 2011

The company of Frédéric, my Ph.D. supervisor, designed the touchscreen allowing to play this game at the exhibition. Frédéric, who tells his side of the story in his blog (in French), was warning me at a coffee break that designing an addictive game (just try it!) is actually quite dangerous. When someone realized that the given answer could be improved, the company started losing all its developers in a obsessive compulsive vortex. He also told me that the current best answer used only 6 numbers. My mission in life became clear: save my fellow nerds using brute-force. Turns out, I just ruined their happiness. I’ll try to make up for it by sharing the fun I had (solving the problem, not ruining their happiness).

Enumerating the candidates

Well, the method is pretty clear: brute force means trying every possibility and checking its validity. The only tricky part is how to enumerate the candidates. This is simpler if we consider only the binary operations first, and consider factorial and square root in a second step.

Noting that applying one of the binary operations will leave us with one less term, we will have to apply n-1 operations on n initial numbers. The orders of the initial numbers is fixed, but the parentheses allow the operation to be between any subsequent terms. In other words, the first operation has n-1 possible pairs of operands, the second operation has n-2, etc. Each operation can be one of the k different (here k = 5), which gives us

(n-1)! * k^n

possibilities to try. It’s good that “my fellow nerds” found that n does not have to be greater than 6…

Now the problem is that unary operations can be applied as often as possible. They can be applied to any of the initial numbers, and to any of the results of the binary operations. However, no factorial is a square (except 1), so we can apply the square root first (as many times as we want), and then the factorial, without trying to interleave them. To be thorough, it could happen that an irrational intermediate result gets multiplied with itself, but a little bird told me that it is a lot less frequent than it would cost to try all the permutations of square roots and factorials.

If we apply up to s times square root on each possible term (i.e. the n initial numbers and the n-1 results of binary operations), and up to f times the factorial on each possible term, that gives us a grand total of

(n-1)! * k^n * (s+1)^(n+n-1) * (f+1)^(n+n-1)

possibilities. It’s really good that n is upper-bounded by 6…

To summarize, we can describe a candidate with:

• a value in the [1,n-1] range, a value in the [1,n-2] range, etc. to code which pair of subsequent operand is used in each of the n-1 binary operation,
• n-1 values in the [1,k] range to code the type of each of the n-1 binary operations,
• n values in the [0,s] range to code how many square roots are applied to the n initial values, and n-1 more in the [0,s] range for the square root applications of each result of the binary operations,
• similarly, n + n-1 values in the [0,f] range for the factorials.

They say a picture is worth a thousand word. The ratio may be a little lower with ascii art, but let’s illustrate these four list item with the winning candidate, i.e. (1+2)!! + 3!^4 - 5. Its evaluation tree looks like that:

1 ---
     \
      3 - 6 - 720 ----
     /                \
2 ---                  \
                        2016
3 - 6 -----------      /    \
                 \    /      \
                  1296        \
                 /             2011
4 ---------------             /
                             /
                            /
5 --------------------------

Beautiful. The binary operations (merging branches) are:

      +          ^      +      -

If +, -, *, /, ^ are respectively coded by 1,2,3,4,5, the second list item will be (1,5,1,2).

The binary operations are applied to the following pair of operands:

      1          3      1      1

which gives us (1,2,1,1) for the first list item. Note that each of these four numbers have been respectively chosen from [1,2,3,4], [1,2,3], [1,2], [1], which correspond to [(1,2), (2,6), (6,4), (4,5)], [(720,6), (6,4), (4,5)], [(720,1296), (1296,5)], [(2016,5)], still respectively. It’s all about respect.

No square root is applied on the initial numbers, and no square root is applied on intermediary result either, so the third list item is (0,0,0,0,0) and (0,0,0,0).

Factorial is applied once on the third initial number (a.k.a. 3), and twice on the result of the first operation, which gives (0,0,1,0,0) and (2,0,0,0) for the fourth list item.

Implementation overview

For the last three item of the previous list, I wrote ExhaustiveEnumeration, a data structure that basically counts in the base corresponding to the range. For example, if n=5 and f = 2, the data structure corresponding to the last item of the previous list will count from 000000000 to 222222222 in base 3. For the first item of the list, the same idea of counting in a different base is used, except the base varies with the position. For example, if n=5, the data structure will count from 0000 to 0123. Both data structures simply provide an accessor to the content, and a method that increments the content and notifies whether a full cycle has just been completed.

Using these data structure, I wrote CandidateEnumeration, a class that fully describes a candidate as described in the previous list. It has a search method that evaluates the current candidate, and generates the next until it fits the criteria. To generate the next candidate, it chains the increment methods of the ExhaustiveEnumeration: if one indicates that a full cycle has been completed, it calls the next.

The evaluation method creates an array of the n initial numbers, and applies the operations coded in the ExhaustiveEnumeration members, until the array is reduced to the ultimate result. If an illegal operation (e.g. divide by 0 or negative square root) is detected, the evaluation is aborted.

The rest of the code is basically here only to output the result or the progress. And of course, indices start at 0 rather than at 1 as in the previous section. And the final binary operation is actually the first of the array of the CandidateEnumeration… Enjoy!

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299

#include <iostream>
#include <cmath>
#include <string>
#include <sstream>

// data structure to count from 0 to UPTO^SIZE in base UPTO+1
// the first FROMINDEX positions remain 0
template <typename T, int SIZE, T UPTO, int FROMINDEX = 0>
struct ExhaustiveEnumeration {
public:
  ExhaustiveEnumeration() {
      for(int i=0; i<SIZE; ++i) mData[i]=0;
  }
  T get(int pIndex) const { return mData[pIndex]; }

  bool increment() {
      int i = FROMINDEX;
      while(i < SIZE && mData[i] >= UPTO) mData[i++] = 0;
      if (i >= SIZE) return false;
      ++mData[i];
      return true;
  }

protected:
  T mData[SIZE];
};

// datastructure to count from 0 to 012..SIZE-1 in "base" 123..SIZE
template <typename T, int SIZE>
struct ExhaustiveEnumerationUpToIndex {
public:
  ExhaustiveEnumerationUpToIndex() {
      for(int i=0; i<SIZE; ++i) mData[i]=0;
  }
  T get(int pIndex) const { return mData[pIndex]; }

  bool increment() {
      int i = 1;
      while(i < SIZE && mData[i] >= i) mData[i++] = 0;
      if (i >= SIZE) return false;
      ++mData[i];
      return true;
  }

protected:
  T mData[SIZE];
};

namespace {
  // I'm too lazy to use some kind of BigInt...
  typedef double Number;

  // ...but not enough to hard code factorial
  const int MAXFACTARG = 20;
  const long factorial[1+MAXFACTARG] = {1,
      1,2,6,24,120,
      720,5040,40320,362880,3628800,
      39916800, 479001600, 6227020800, 87178291200, 1307674368000,
      20922789888000, 355687428096000, 6402373705728000, 121645100408832000,
      2432902008176640000};

  // floating point equality
  inline bool equals(Number a, Number b, Number epsilon) {
      Number tDelta = a-b;
      return (-epsilon < tDelta && tDelta < epsilon);
  }

  // test whether a floating point is (clos enough from) an integer
  inline bool isInt(Number a, Number epsilon) {
      return equals(a, static_cast<Number>((long) a), epsilon);
  }
}

// n = NOPERANDS, f = MAXFRAC, s = MAXSQRT
template<int NOPERANDS = 5, char MAXFRAC = 2, char MAXSQRT = 2>
class CandidateEnumeration {
public:
  CandidateEnumeration():mPairPositions(),mOps(),mFacs(),mSqrt() {}

  // see decode(EvaluationResult) for a description
  enum EvaluationResult {
      CORRECT = 1,
      DIVISION = 2,
      FAC_TOO_MUCH = 4,
      FAC_NON_INT = 8,
      FAC_TOO_BIG = 16,
      SQRT = 32,
      INCORRECT = 64};

  // mainly do{evaluateCandidate()} while (generateNextCandidate());
  // the rest is just progress output
  // 
  // ALL choose whether all candidates should be tried,
  // or if the search can be stopped after the first success
  // 
  // VERBOSITY is the bitwise or combination of the EvaluationResult types
  // which should be printed
  template <bool ALL, int VERBOSITY>
  void search(Number expectation, const Number epsilon = 0.1) {
      EvaluationResult result;
      long tRemaingCandidates = factorial[NBINOPERATIONS]
                        *pow(NBINOPERATIONTYPES,NBINOPERATIONS)
                        *pow(MAXFRAC+1,NBINOPERATIONS+NOPERANDS-2)
                        *pow(MAXSQRT+1,NBINOPERATIONS+NOPERANDS-1);
      std::cout << tRemaingCandidates << " candidates" << std::endl;
      do {
          result = evaluateCandidate(expectation, epsilon);
          if (result & VERBOSITY) {
              std::cout << decode(result) << ": ";
              printCandidate();
          }

          --tRemaingCandidates;
          if (ALL && !(tRemaingCandidates%100000000)) {
              std::cout << tRemaingCandidates << " remaining candidates"
                      << std::endl;
          }
      } while (generateNextCandidate() && (ALL || result != CORRECT));
  }

  void printCandidate() {
      std::string tCandidate[NOPERANDS];
      for (int i = 0; i < NOPERANDS; ++i) {
          std::stringstream tOperand;
          tOperand << (i+1);
          tCandidate[i] = buildNode(tOperand.str(),
                  mSqrt.get(i), mFacs.get(i));
      }
      for (int i = NBINOPERATIONS-1; i >= 0; --i) {
          int tPairPositionIndex = mPairPositions.get(i);
          tCandidate[tPairPositionIndex] = '('
                  + tCandidate[tPairPositionIndex]
                  + decode(mOps.get(i))
                  + tCandidate[tPairPositionIndex+1] + ')';
          tCandidate[tPairPositionIndex] = buildNode(
                  tCandidate[tPairPositionIndex],
                  mSqrt.get(NOPERANDS+i), mFacs.get(NOPERANDS+i));
          for(int j=tPairPositionIndex+1; j<NBINOPERATIONS; ++j) {
              tCandidate[j] = tCandidate[j+1];
          }
      }
      std::cout << tCandidate[0] << std::endl;
  }

  // helper of printCandidate()
  std::string buildNode(std::string pCore, int pNSqrt, int pNFac) {
      if (pNSqrt>0) pCore = '('+pCore+')';
      for (int k = 0; k<pNSqrt; ++k) pCore="√"+pCore;
      if (pNFac>0) pCore = '('+pCore+')';
      for (int k = 0; k<pNFac; ++k) pCore+='!';
      return pCore;
  }

protected:

  // decode the current candidate and check whether it's the expected result
  // or abort if an operation is not possible
  EvaluationResult evaluateCandidate(
          Number expectation, const Number epsilon = 0.1) {

      // initial numbers and corresponding factorials and square roots
      Number tResults[NOPERANDS];
      for (int i = 0; i<NOPERANDS; ++i) {
          tResults[i]=i+1;

          for (int k = 0; k<mSqrt.get(i); ++k) tResults[i] = sqrt(tResults[i]);

          for (int k = 0; k<mFacs.get(i); ++k) {
              if (tResults[i] > MAXFACTARG) return FAC_TOO_MUCH;
              tResults[i] = factorial[(int) tResults[i]];
          }
      }

      // fetch the operation type and operand pair, compute result
      // and apply corresponding factorials and square roots
      // 
      // the result is stored in the cell of the first operand,
      // and the intermediary results after the second operand are shifted
      for (int i = NBINOPERATIONS-1; i >= 0; --i) {

          // binary operation
          int tPairPositionIndex = mPairPositions.get(i);
          switch (mOps.get(i)) {
              case 0: tResults[tPairPositionIndex] +=
                      tResults[tPairPositionIndex+1]; break;
              case 1: tResults[tPairPositionIndex] -=
                      tResults[tPairPositionIndex+1]; break;
              case 2: tResults[tPairPositionIndex] *=
                      tResults[tPairPositionIndex+1]; break;
              case 3: tResults[tPairPositionIndex] /=
                      tResults[tPairPositionIndex+1]; break;
              case 4: tResults[tPairPositionIndex] =
                      pow(tResults[tPairPositionIndex],
                              tResults[tPairPositionIndex+1]); break;
              default: std::cerr << "Unexpected opcode:"
                      << (int) mOps.get(i) << std::endl; break;
          }
          if (std::isnan(tResults[tPairPositionIndex])
              || std::isinf(tResults[tPairPositionIndex])) return DIVISION;

          // square roots
          if (mSqrt.get(NOPERANDS+i) > 0
                  && tResults[tPairPositionIndex] < 0.0) return SQRT;
          for (int k = 0; k<mSqrt.get(NOPERANDS+i); ++k) {
              tResults[tPairPositionIndex] =
                      sqrt(tResults[tPairPositionIndex]);
          }

          // factorial
          if (mFacs.get(NOPERANDS+i) > 0
                  && !isInt(tResults[tPairPositionIndex], epsilon)) {
              return FAC_NON_INT;
          }
          for (int k = 0; k<mFacs.get(NOPERANDS+i); ++k) {
              if (0 > tResults[tPairPositionIndex]
                  || tResults[tPairPositionIndex] > MAXFACTARG) {
                  return FAC_TOO_BIG;
              }
              tResults[tPairPositionIndex] =
                      factorial[(int) tResults[tPairPositionIndex]];
          }

          // shifting the intermediate results
          for(int j=tPairPositionIndex+1; j<NBINOPERATIONS; ++j) {
              tResults[j] = tResults[j+1];
          }
      }

      return equals(tResults[0],expectation, epsilon)?CORRECT:INCORRECT;
  }

  // chains the increments
  bool generateNextCandidate() {
      return mOps.increment()
              || mPairPositions.increment()
              || mFacs.increment()
              || mSqrt.increment();
  }

  // opcode to char
  static char decode(char op) {
      switch (op) {
          case 0: return '+';
          case 1: return '-';
          case 2: return '*';
          case 3: return '/';
          case 4: return '^';
          default: return '?';
      }
  }

  // describes an EvaluationResult
  static const char *decode(EvaluationResult result) {
      switch (result) {
      case CORRECT:
          return "Solution found";
      case DIVISION:
          return "Division impossible to perform on an operator";
      case FAC_TOO_MUCH:
          return "Factorial impossible to perform on a base operand";
      case FAC_NON_INT:
          return "Factorial impossible to perform on non integer";
      case FAC_TOO_BIG:
          return "Factorial impossible to perform on an operation result";
      case SQRT:
          return "Square root impossible to perform";
      case INCORRECT:
          return "Invalid candidate";
      default:
          return "Unexpected result code";
      }
  }

  // count of binary operations (n-1)
  static const int NBINOPERATIONS = NOPERANDS-1;
  // count of types of binary operations (k)
  static const int NBINOPERATIONTYPES = 5;

  // position of the pair of operands of each binary operation
  ExhaustiveEnumerationUpToIndex<char, NBINOPERATIONS> mPairPositions;
  // type of each binary operation
  ExhaustiveEnumeration<char, NBINOPERATIONS, NBINOPERATIONTYPES-1> mOps;
  // count of factorials to apply on each initial number or operation result
  // it's useless to try to increase the count of factorials applied to 1 and
  // 2, so we skip the first 2 indices in the enumeration
  ExhaustiveEnumeration<char, NOPERANDS+NBINOPERATIONS, MAXFRAC, 2> mFacs;
  // count of square roots to apply on each initial number or operation result
  // it's useless to try to increase the count of square root applied to 1
  // so we skip the first  index in the enumeration
  ExhaustiveEnumeration<char, NOPERANDS+NBINOPERATIONS, MAXSQRT, 1> mSqrt;
};

int main() {
  typedef CandidateEnumeration<5,2,2> Candidates;
  Candidates tCandidates;
  tCandidates.search<true, Candidates::CORRECT>(2011);
  std::cout << "Done" << std::endl;
  return 0;
}

Limitations

The main limitation of this code is that the number representation (long) does not allow to compute the factorial of numbers above 20, which aborts the computation of potentially correct candidates. The use of double also results in false positive due to rounding errors.

The limitation to this brute force algorithm in general is that there is obviously no end in the increase of the number of application of factorial and square root. I can’t think of an upper bound on f and s after which there is no possible solution any more.

That and the lack of interleaved factorials and square roots leaves the door open to solutions with less than 5 initial numbers. I would bet that there aren’t any, but I’m not sure how to prove it.

Finally, this code can easily be used to play “The answer is 2012”. I wonder if there are years for which this code is unacceptably long, i.e. years that would require “a lot” of initial numbers…

Comments

I posted this story on HackerNews and got some interesting feedbacks.

Use-case

I discovered SparkleShare today and decided to use it to replace Ubuntu One, in a quixotic quest of having total control over my cloud one day. One of my uses of Ubuntu One is for synchronizing some configuration files (~/.bash_alias, ~/Templates, etc.) in a common folder (say, configs). Link to these files replace the actual files. e.g. :

1
2

ln -s ~/configs/.bash_alias ~/.bash_alias
ln -s ~/configs/Templates ~/Templates

I use my own server as a host of my SparkleShare projects, and I want to use my configuration files on this server.

My adventures in finding a solution

I started to search for some headless SparkleShare daemon that would synchronize the configs folder with the git repository that SparkleShare uses as a synchronization hub. Apparently there is a headless version of SparkleShare, but it doesn’t seem very clean, so I started playing with the git repository. Puzzled by the --bare option, I found a post explaining how to auto-publish a website using git. It provided me with a solution to my problem, in combination with the instructions to set up my own server from SparkleShare.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#create a new SparkleShare project:
git init --bare configs.git
cd configs.git
#tell git that the repository is not just a repository
git config core.bare false
#tell git where to extract the working copy
git config core.worktree ~/configs
#tell git not to complain about this apparently bad practice
git config receive.denyCurrentBranch ignore
#tell git to update the working copy
#each time the repository receives a new commit
cat > hooks/post-receive <<EOF
#!/bin/sh
git checkout -f
EOF
chmod +x hooks/post-receive

Conclusion

That’s it! Now the file you put from other machines in the configs project will be created/updated in the ~/configs folder on the host.

PS: if you’re an experienced git user and you’re having a heart attack, it’s probably due to my lack of git terminology and/or git good practice. As an excuse, it is the first time I go beyond git clone, but you will probably recognize the mark of an evil bzr user ;)… So I would be happy to get some constructive feedback on my git usage, or maybe on the SparkleShare feature that I missed and that does exactly what this post describes, only better…