matthiasv

> How do you deal with Cash?

Move money from Asset:Checking to Expenses:Cash

> How do you deal with interest?

Move money from Income:Interest to Asset:Depot

> How do you keep your bank statements?

I download CSVs once in a while an import them with hledgers import tool (see https://bloerg.net/2016/02/22/ledger-import-of-deutsche-bank...)

> How do you convert your balance sheet into a tax filing compatible format?

I don't, sorry. But it's actually pretty easy to get the relevant data if you split your taxable incoming accordingly.

> How do you track things like rent? Do you keep it as a recurring entry i.e. `~ Monthly` or do you only book it when you pay with buchhaltung?

It's part of the bank statement, so yes it moves money from Assets:Checking to Expenses:Rent whenever the transaction happens.

> How do you track small expenses on the go?

I don't. After a while I found it's not worth the effort. I rarely make financial decisions based on how much I spent on beers and sandwiches, so most of these little things are just subsumed in Expenses:Cash.

How do you model double-entry book-keeping in your relational database? And where comes the fear of corruption if .ledger files are merely text?

Meson is written in Python not "actually Python". The build language is a custom non-Turing-complete DSL.

That looks actually more like a use case for a context manager, i.e.

     with transactional as transaction:
          # do something

It's pretty clear at the call site what is and what isn't transactional and most importantly is practically the pythonic way of writing code with guaranteed cleanup.

We build something like this for image processing tasks: https://github.com/ufo-kit/ufo-core

There is also a CLI interface that allows in principle what you want to do, e.g.

     $ ufo-launch read path=foos.bin ! opencl filename=frobnicate.cl kernel=frobnicate ! fft ! blur ! write filename=bars.tif

For me, rebasing usually concerns roughly the last N commits, which is why I don't bother running `git rebase -i HEAD~N` and ignore and commits I don't want to modify.

His point is that this cookie-cutter approach is more complex to the development model he presents (and is in fact pretty common among open source software). You don't need to understand Git deeply to realize that master is stable and merges in finished and cleaned up features.

Vulfpeck is also the hottest funk band that currently rocks this planet. But as it seems, I should rather purchase their albums from Bandcamp than streaming them via Spotify.

That format is essentially (sans the link syntax) what plaintext email has been looking like for decades. I don't get the whole praise for Gruber of "inventing" something novel. It's not.

But as long as the correct HTML is output it doesn't matter how it looks. I mean that's the whole idea of separating structure from representation, right?

It's because of this line: https://github.com/jgm/stmd/blob/e47d698c2cf1d24606bd2f708fe...

But seriously, who cares?

If you do know screen, then tmux is going to blow your mind.

Here is a Python client library [1]. It's really amazing how fast I could put this together. Thanks Guido and Kenneth ;-)

[1] https://github.com/matze/python-phant

It would be nice, if the author would back his claims by specific references. Comparing the upstream tracker reports for GTK+ and Qt shed a different light on ABI compatibility between versions:

http://www.upstream-tracker.org/versions/gtk+.html http://www.upstream-tracker.org/versions/qt.html

(Yes, yes, Qt does more than just GUI, I know …)

I tend to disagree a bit here. Yes, that's how most bike lanes are laid out at the moment but in my experience, more and more bike lanes are moved on the road and inbetween car lanes to let cyclists become more visible. I welcome that because one can go much faster without having to take care of pedestrians.

You may give Sigal a try: https://github.com/saimn/sigal/

Germany is definitely not a tea country, yet everyone I know has an electric kettle.

The novelty I see here, is the combination and integration into an app. Creating blurred images from a photograph and its depth map can be achieved with a GIMP plugin since at least 2008 [1]. Combining a series of photos to create a 3D model is also widely implemented, e.g. in the Photosynth application developed at U Washington/Microsoft which according to Wikipedia exists as a tech preview since 2006.

[1] http://registry.gimp.org/node/1444

For me, IPython will always be a double-edged sword. On the one hand I love what the project brings in terms of scientific exploration and ease of use. On the other hand it is annoyingly hard to integrate the shell into my own application: the API changes way too often and the source is a very complex and tangled mess.

Sure, if you do the packaging for a restricted set of environments yourself, CMake certainly works fine. I do the same for a lot of projects and know what CMake is capable of.

But when it comes to the differences between all those Linux distributions, the respective packager will be very glad to see that he can customize install prefixes (no, CMAKE_INSTALL_PREFIX is not enough) and use standard make targets.

Your list of dependencies shows libraries that are well covered by the stock CMake modules but try getting a build variable that is not LIBS or CFLAGS from a library that can only be queried with pkg-config. Impossible.

> It just replaces the most of the autoconf mess.

With a non-standard mess on its own ...

CMake is pretty bad at doing things (standard paths, install targets etc.) that the GNU folks solved a long time ago. Yes, the Autotools are a royal PITA but at least a pain that one knows how to deal with.

I don't know your exact use cases but I am reallyfond of pgfplots which, being based on TikZ, integrates much better than matplotlib. But I also happen to hate matplotlib for sticking with "that" API ...

I am not saying it is hard, I just wanted to point out that CMake does not provide something like this out of the box. Quite the contrary, now every developer has to re-invent this tiny wheel, and I've seen this going wrong several times.

However, CMake sucks in terms of installation paths. Ever tried installing a library into a libdir other than ${prefix}/lib? In the worst case, the developer tries to "fix" this by guessing the architecture and append a magical 64. This works on some distributions but of course not all of them.

I got sick and tired of this situation and wrote a small CMake module [1] that accepts standard configure options to determine the installation path.

[1] http://bloerg.net/2013/10/29/turning-cmake-into-a-good-unix-...

> SDS is a string library for C [...]

Function overloading does not exist in C.

HTML is part of the "specification" of Markdown. And you really want to "spice up" your markup with CSS? I'd rather spent the time on content.

> I really don't understand the mindset that takes people from "hey look somebody wrote a free piece of software I can use if I want" to "what, now I need to use yet another piece of software for something?"

It's not that I stop people from doing things they want to do. I just wanted to point out that something seemingly simple as writing a README usually does not require yet another tool that has to be learned and – being a dependency – maintained.

Good point about those many versions. It's actually the first time that I've seen multiple READMEs in one project.

So, for the simplest tasks such as writing a README you need a Ruby gem these days? Or is it some satire which I didn't get yet?

(Just to clarify my position: I am all for automatizing daunting tasks as much as possible, but this seems to be a little far-fetched.)

The often cited requests library, flask and Django. Some counter examples are high profile projects such as IPython and Matplotlib.