The new EU VAT rules are bad for business

On paper, I mostly think the EU is a great idea. The Euro currency too. It fits well with one of the most loudly broadcasted purposes of EU; to strengthen and easen trade between member countries. Well, it's not officially phrased that way, but you'd be hard pressed not to interpret the Treaty on European Union that way:

DETERMINED to promote economic and social progress for their peoples, taking into account the principle of sustainable development and within the context of the accomplishment of the internal market and of reinforced cohesion and environmental protection, and to implement policies ensuring that advances in economic integration are accompanied by parallel progress in other fields,

Anyone who runs anything but a local — as in brick and mortar style — business should think this is a great idea. Essentially, it should widen the adressable market for a business with little to no overhead, give or take your sales channels. For Internet companies, this is awesome. Gone are the odd trade agreements between neighbouring European countries, replaced with a simple, consistent model, which everyone agrees on.

For Iconfinder, this has been especially great; we only need to deal with the distinction between EU and non-EU customers, and in the case of EU customers, whether they're valid legal entities or simply consumers. Based on this information, it's pretty simple to figure out what to do about VAT. That part about "valid legal entity" is actually not that simple, though, as you are actually required to verify the validity of a legal entity. For this, the EU has a mostly unstable Web service (SOAP, of course), VIES, which is woefully underdocumented, but if you do a bit of work, like we have with our pyvat Python module, you can pretty easily automate this process. It sure as hell still beats dealing with whatever trade agreements existed before the EU.

It's all down hill from here

But, all these good things are going to come to a screeching halt on January 1st, 2015, at least if you're in the broadcasting, telecommunications, or, in our case, "electronic services" category of businesses. If you're so lucky as to be one of these businesses, you now no longer have to pay your local VAT rate to the country in which you operate, when you sell to a consumer in the EU. Instead, you now have to pay VAT in the consumer's country of residence at the rate applicable to the good, you're selling, in that country.

In other words, until January 1st, when Iconfinder sells an icon to a consumer in Malta, we have to pay 25 % VAT to the Danish government on the sale. From January 1st, we have to pay 18 % VAT to the Maltesian government instead. This alone, in my opinion, is unnecessarily complex. Think about it; we now have to keep track of VAT rates in all individual EU countries. Sure, the EU published a set of instructions containing a table of these rates, on their 1995 style VAT insanity page, but there's no obvious way of being subscribed to notifications on changes. Pray that your accountant will keep an eye on that for you, or hope that you remember to visit that site every so often.

But, wait, it gets better. Some countries have varying VAT rates depending on where in the country the consumer lives. Some Greek islands have a discounted VAT rate of 16 % instead of the normal 23 %, so you're now stuck with having to figure out if that's the case. As anyone who's ever tried to parse or validate adresses knows, doing this consistently from user input is going to be borderline impossible. And, then, of course, there's the varying VAT rates depending on the good you're selling. In France, e-books are sold at a 5.5 % VAT rate as opposed to the standard 20 % rate, and e-newspapers (whatever they are, exactly) are sold at an even lower rate of 2.1 %. Then, lastly, there are little details like the "use and enjoyment" VAT levying rule, which is of course only applicable in certain countries.

None of this is exposed in any useful manner. It's 2014 and the EU did not think to make it easy for businesses to comply with these rules by, say, exposing this information through a Web service. Instead, your get a PDF summary and a bunch of documents to read, understand and implement. Have fun.

As for the question of actually paying the VAT owed to ther countries, the EU did actually decide to use some new fangled technology in offering a consolidated platform for payment, the "MOSS," or "Mini One Stop Shop" (who names these things!?) Knowing how well these things usually work, it'll probably be utterly useless and a huge headache for the next couple of years, but at least they tried.

Now, as if all of this wasn't ridiculous enough, the EU laments its self-image of being an economic super power by maintaing the ridiculous rule of countries outside the EU selling to consumers in the EU technically being required to pay VAT in the country where the consumer lives. This is of course in spite of the fact that the rules state, that businesses in the EU doing selling to consumers outside the EU are no longer required to deal with any kind of VAT payments. Fat chance that American companies will start charging me Danish VAT from January 1st, especially when this is now a one-way street.

It's a treaty breach

The only real upside I can see, is that we'll improve our margins slightly as only few other countries in the EU have as ridiculous a VAT rate as Denmark. I'm just not sure it's worth it in time and complexity, not to mention development, bookkeeping and accounting costs.

I honestly think that, if you squint your eyes a little, these new VAT rules are counter to the stated purpose of the EU, and in essense, a breach of the stated goal in the aformentioned treaty. Sure, getting VAT to the country, where a good is consumed makes theoretical sense, as VAT is essentially a consumption based income tax. As so-called electronic services are becoming an ever increasing economic force, this of course skews the balance. However, it's at the expense of the businesses providing these services. The overhead is substantial, and in that regard raises the barrier to entry for any business wanting to do business with consumers in EU countries — albeit most notably for EU businesses, as the rules can actually be legally enforced here. Sustainable? Maybe — those with skin in the game will manage and adapt. Does it promote economic progress? Definitely not.

The next weeks of my life will be spent implementing a good way to handle these new rules and testing to make sure everything works according to plan. What a royal waste of time, energy and money.

December 12, 2014 | Permalink


Tracking down a rogue kernel_task

I'm one of the lucky ones who have the pleasure of working on a 2014 Mac Pro (yes, the trash can) every day. I love it to bits. It's blazingly fast, never misses a beat and no matter what I feel like doing, resources are never a constraint. However, my particular Mac Pro has been a bit wonky from the start. Ever so often (somewhere between once a week and three times a day), the kernel will start spinning out of control on one of the cores. As a side effect, applications will start hanging, and the system basically becomes useless until I force a reboot (once the kernel finds itself in an endless loop, a graceful shutdown goes out the window — the best you can do is try to issue a sync to make sure the file system will come back up in a reasonable state, but with HFS+, you never really know.)

The dreaded kernel_task at 100 % CPU usage

The usual remedies haven't helped. Reset this, reset that, full reinstall and so on. For the longest time, then, I've just ignored the issue. It wasn't sufficiently annoying to warrant working from my laptop for however long it would take to fix the issue. However, after a series of all too frequent incidents in the last couple of weeks, I decided to take affair. Given that I haven't been able to isolate the trigger of the problem, I decided to try and gather as much data as I could, as searches on the matter of kernel_task running at 100 % yielded so many different explanations, none of which seemed directly applicable to my situation. Giving Apple's support a call and saying "I occasionally get kernel_task stuck on a core" would probably not be of much use to anyone, then. What I needed to do, was to figure out exactly what was going on in the kernel at these times.

Luckily, Mac OS X ships with every developer's wet dream, dtrace. Even better, Brendan Gregg made a simple Perl script back in 2006 to sample calls in the kernel using dtrace, which almost works today. Given the "almost" part, and the fact that I like more readable output for debugging, I decided to whip up a quick improvement in Go, osxkerneltracer, which I've been using for the past couple of weeks to gather evidence whenever this problem occurred.

On my machine in its normal state, the output looks something like this, after sampling for 5 seconds:

Module            | Method                                                 | Calls |      Share
------------------+--------------------------------------------------------+-------+-----------
kernel            | machine_idle+0x1fd                                     | 49756 |  98.4819 %
kernel            | 0xffffff801cd52880+0x313                               |   240 |   0.4750 %
kernel            | processor_idle+0xc5                                    |   101 |   0.1999 %
kernel            | processor_idle+0xb4                                    |    41 |   0.0812 %
kernel            | do_mfence+0x3                                          |    27 |   0.0534 %
kernel            | dcache_incoherent_io_store64+0xab                      |    23 |   0.0455 %
kernel            | ipc_mqueue_post+0x227                                  |    18 |   0.0356 %
kernel            | machine_idle+0x1ff                                     |    18 |   0.0356 %
kernel            | 0xffffff801cd52880+0x3bf                               |    17 |   0.0336 %
kernel            | processor_idle+0xd9                                    |    10 |   0.0198 %
kernel            | processor_idle+0xab                                    |     7 |   0.0139 %
kernel            | user_trap+0x9f                                         |     7 |   0.0139 %
kernel            | wait_queue_wakeup_all+0xb9                             |     7 |   0.0139 %
AMD7000Controller | _OSReadInt32(void const volatile*, unsigned long)+0x1a |     6 |   0.0119 %
kernel            | thread_block_reason+0xbe                               |     6 |   0.0119 %
kernel            | processor_idle+0xbb                                    |     5 |   0.0099 %
kernel            | 0xffffff801cd6acc0+0x2d0                               |     4 |   0.0079 %
kernel            | __bzero+0xb                                            |     4 |   0.0079 %
[...]

This is basically what you'd expect from a system at almost idle; most of the time in the kernel is spent in an idle function — in this case, the kernel's machine_idle function (as a side note, for a kick, read up on how this actually works.) When things go awry, it's always the same thing that happens. That innocent 32 bit read function to the AMD 7000 controller you can see in the call trace above suddenly represents roughly 6.25 % of the calls traced — the full share of one of the 16 hyper-threaded cores on this machine. In other words, the kernel seems stuck in an endless loop trying to read data from the graphics controller.

With this data in hand, I've now contacted Apple support, who immediately bumped the issue to a guy who understood what not only a kernel is, but also knew that dtrace existed (in other words: data expedites support when dealing with intermittent issues.) I agreed to ship a bunch of logs for them to look at before taking the next step of actually taking the machine in, and I'm now waiting to see what they come back with.

If you're experiencing similar, intermittent issues, I suggest you do the same thing. It'll save you and probably also the immediate support staff a lot of time fumbling in the dark and will much more easily get your issue bumped to the right level, if it's actually Apple's problem.

November 11, 2014 | Permalink


Source code optimization

For some reason, I wound up reading about compilers' use of vectorization in optimizing code yesterday, and I came across Felix von Leitner's pretty interesting presentation from 2009, "Source Code Optimization".

While I knew that compilers are generally good at optimizing these days, I had no clue just how good they've become. This basically also means that a lot of the "general wisdom" I came up with when writing C and C++ no longer really applies, and even more so, that more readable code often seems to produce equally good or even more optimized code than most attempts at being clever. For C(++) code then, this means that we not only can but almost have to mentally shift from being "clever" to being concise when writing code – a development that's been helped greatly by C11 and C++11.

If you write any C or C++ on a regular basis, I strongly suggest you add this presentation to your list of annual reminders.

October 19, 2014 | Permalink


The ultimate ops job

I don't often care to broadcast anyone's job openings. Most of the time, it's someone looking for the stealth Japanese warrior equivalent of the coding Albert Einstein anyway. But, if you're in Europe and have a knack for ops, what might just be the ultimate ops job has just opened up at my previous employer and good friends, 23.

Back when I was working at 23 a little over two years ago, they were already among the larger Northern European Web outfits on pure traffic and volume. It was a challenge to develop and run even back then – a challenge, I learned a heck of a lot from. Since then, they've grown significantly while keeping a pretty impressive product edge over the competition, which means that the person to take over ops at 23 is being served one hell of an awesome challenge in the most non-corporate of environments (I got away with flip flops for a long time), working alongside the product people.

The challenges aside, I can personally vouch for the fact that the person to take the job will be working alongside an awesome bunch of people. From your quintessential hipster dad through to your creative Polish accountant, the whole lot is both lovely and ambitious, with a culture most companies should be envious of.

So, allow me to make an exception here: if you're looking for an ops job that's going to teach you a hell of a lot about running Web software at scale and throw challenges at you every day while getting to work alongside a brilliant bunch, you should seriously have a chat with the guys at 23. The only downside? You might be exposed to something I built years ago. It probably isn't pretty. Don't say you weren't warned.

October 10, 2014 | Permalink


Smart working

Startup culture is awash with the heroisation of burning the mythical midnight oil with the 60 or 70 hour work week being a badge of honor — the road to success. Slowly, however, that trend is changing — at least among people who've actually done those stupid hours — and while I'm embarrassingly still working way too many hours than is any kind of good, evidence keeps indicating that I really need to stop. Not only evidence in terms of feeling unproductive at times, but actual sort of scientific evidence.

I came across one such piece of evidence today in CamMi Pham's post "7 Things You Need To Stop Doing To Be More Productive, Backed By Science". For the post, she has done a couple of very tangible charts (which seem to correlate well with other data I've found) showing the effective productivity of weeks of working 50 and 60 hours respectively. Truth be told, the numbers are scary — if the charts are to be taken at face value, the productivity gain from a 50 or 60 hour work week evaporate after only 9 and 8 weeks respectively:

Productivity over overworking duration - by CamMi Pham

I probably need to be smart and go home "early."

July 30, 2014 | Permalink