Don't be a moran!

The Dutch statistics agence (CBS) is reporting how many 'extra' casualties there are in total compared to "normal". Assuming nothing else is going on, it's likely that most of these deaths are due to COVID-19*. Here are the official statistics compared to the suplus deaths for the past two weeks:

Wk | Official COVID-19 deaths | Total 'surplus' deaths | ratio
13 | 752 | 1,293 | 1.7
14 | 1,016 | 1,968 | 1.9

I believe that the Netherlands is probably the most "optimistic" in their reporting as they only report positively tested casualties and testing is almost completely restricted to hospitals due to a lack of tests. So, it seems that even in these circumstances COVID-19 deaths are underreported by "only" about a factor 2.

Source: https://cbs.nl/nl-nl/nieuws/20...

* Directly or indirectly, e.g. due to reduced other care; of course, with a country in lockdown a lot of things might not be 'normal', e.g. reduced traffic fatalities, fewer workplace accidents, etc., but I would assume

FTFY

Yeah, that's not a yacht, that's a fishing boat :)

You should try R :)

That's because 1.2M of these lines are boilerplate interface definitions, getter/setter routines, useless class hierarchies, and endless try/catch/throw blocks because you are using package Y which throws exception E while the interface you implement only allows you to throw exception F.

Your 1.3M java code base is probably about 1.3kloc python :-) /me ducks

I think this is such a red herring. The only significant whitespace in python is for delineating blocks. Any properly styled project will always follow proper whitespace rules, which means python and C/... code will be identical save replacing the opening curly brace by a colon and skipping the closing curly brace.

Braces blocks allow you to mismatch visual indentation and block structure, which can lead to bugs or misunderstandings. However this should be quickly caught by a proper IDE. Whitespace blocks require a bit more IDE support to move around and increase/decrease indent, but you were going to need this to fix the indent anyway with braces blocks.

Tabs vs spaces is an annoying discussion, and tabs make more sense 'intellectually', but the PEP-'mandated' spaces are fine too and all IDEs I know deal with this. Copy/pasting coding can sometimes give trouble, but you really shouldn't be copy/pasting code without checking every line anyways :)

Conclusion: IDE support means that curly braces or whitespace are both totally fine for delineating blocks. This is a non-discussion. Let's talk about language features that actually make it easier to write/maintain/run certain classes of programs.

If you think you can directly compare artificial neural networks and biological brains, you are missing a couple orders of magnitude in terms of complexity.

I may seem that the abstraction in ANNs, where each neuron is simply some form of $f(w.x)$, captures the essence of real neurons, but it turns out that a lot of the 'smarts' in brains come from the deviations from that abstraction, in terms of neurotransmitters, delays, sauration, etc. etc.

OTOH, my cat worries about a lot of things that my car doesn't necessarily need to worry about. If abandon my cat into the woods, he has a decent shot at surviving. I don't expect my car to fend for itself when the revolution comes.

Another analogy, look at how wasps are able to navigate, react to the environment, attack prey, defend itself and the hive, etc. - with a total brain volume of <1mm^2, or about .0001% of the human ~1 liter (1200cm^2). I'm not saying I would trust a wasp to drive my car (the only good wasp is a dead wasp if you ask me), but I think it is clear that you can't just compare ANN "neuron" counts to brain sizes and make statements about possibilities, certainly not at any precision near a single order of magnitude like "10-30x".

Sources:

• https://towardsdatascience.com...
• https://doi.org/10.1093/biolin... [on wasp brain size, use scihub if you really want to read :-) ]
• https://en.wikipedia.org/wiki/...

Back here public transport is generally safe and clean. If there's a problem with "the public" using it it is that rush hour trains are overcrowded. Between major cities trains run at 10-minute intervals, so if you miss a train the wait is 10 minutes. I even live in the city center within easy distance of the central station.

Still, I own a car and use it at least as often as the train. Why? Trains are not very good at going to non-urban places, and trains are not very good at going to the DIY store and bringing back a lot of stuff. As a resident, I have permit parking in my street, but my car is collecting rust (and disturbing amounts of bird poo) most of the week.

I wouldn't think twice if I could replace my car by a shared self-drive vehicle, assuming that it makes economic sense. We considered car sharing, but for things like visiting relatives for a weekend the hourly rates are horrible. Of course we could car share for short trips, and take a rental for longer trips, but that just becomes complicated really fast...

Not quite. If you look at the trends and take out the seasonal variation, you'll see that wind (and some bio) has actually replaced coal, with gas and nuclear staying mostly constant: https://i.imgur.com/fkeAk8G.pn...

The picture is even clearer when you plot fossil vs renewable vs other: https://i.imgur.com/9WZZ0hJ.pn...

Source: https://gist.github.com/vanatt...

You wonder whether a multi-billion dollar industry would use a simple online tool to optimize their routes to reduce their 2 biggest costs (fuel and aircraft+crew hours) and service their customers better at the same time? :D

What does it mean that the system is said to be 90% accurate?

If this is indeed a simple accuracy (sensitivity) measure, it means that 1 in 10 readings will be wrong. So, if someone is driving a stolen car, there's a 10% chance the system will incorrectly fail to identify him/her. That's the easy part :)

There are 250M cars in the US, and each year .7M are stolen. Let's assume an average stolen car is driven for a month. That would mean that about 1 in 5000 cars is actually stolen (which is probably a huge overestimate as I would guess most stolen cars are scrapped, exported, or abandoned pretty quickly).

Now, let's assume 50000 cars are scanned, of which 10 are actually stolen. This will give 9 true positives (90% x 10), and 4999 false positives (10%*49990). So the chance that a car is actually stolen would be 9/5008 or about a tenth of a percentage.

The more reasonable assumption is that a wrong scan will give a random different number plate, which most likely does not belong to a stolen car - the chance of getting falsely assigned a stolen car plate is 10% (error rate) * .0002 (prevalence) = .00002. So, the chance of getting flagged in a stolen car is 90% + .00002 = .90002. The chance of getting flagged in a non-stolen car is simply .00002.

Now, out of our 50k scanned cars, we still get about 9 TPs, and now get about 1 (.000002*49990) FP. In other words, it turns out 1 in 10 people are falsely accused (not a very good ratio for drawing guns if you ask me). Of course, this is assuming stolen cars drive the same amount of miles as non-stolen cars. If non-stolen cars drive 10x the miles (ie are 10x as likely to be scanned), because stolen cars are abandoned, scrapped, or exported, this changes to about 50/50.

(the obvious solution, of course, is to manually check plate and car make and color before drawing guns...)

I see the same in higher education. There's a number of things we all need (like an electronic learning environment) but we buy it from vendors like Canvas or Blackboard, which is expensive and inflexible. Same for grading systems, scheduling, course guides, human resource, etc.

I think we should have moved to a cooperative structure for these things long ago and all pay into a group that develops the software and then releases it open source. Since this can be decided at the university system level there's less risk of freeriding, and since universities employ a lot of smart people who like tinkering there will be a lot of community contributions.

Not sure if you were serious, but I'll bite.

I've programmed in quite a bunch of languages (in somewhat chronological order, BBC Basic, QBasic, Pascal, Perl, Java, C#, Prolog, C++, Python, R, JS/ES6) and I absolutely prefer python.

The brackets vs whitespace thing is a big red herring. It enforces clean indentation and reduces clutter, which is nice. It makes copy pasting sometimes a bit more difficult, which is annoying. Most of the time, I don't care.

The real benefits of python, imho, are:
- a mostly sane language, good OO and functional support without forcing a paradigm on you,
- a very good standard library and very good external packages for almost everything,
- all the performance you want by dropping a module down to C without the rest of the program noticing.( I don't write a lot of C myself, but I certainly profit from the good folks who wrote parts of the standard library in C and who wrote packages like numpy, spacy, pytorch etc.)
- it's relatively free of gotchas or weird syntax and exceptions, invites a clean coding style, and has a very nice community and documentation.
- I also believe dynamic typing with type hints is actually superior to static typing, as with C++/Java you write so much useless class and interface boilerplate that only distracts.
- I also love the ease of doing things like function pointers, decorators, list/dict expressions and unpacking, generators/iterators, catch-all arguments, etc etc.

Now, all languages are compromises and some languages are better at some of these points, but overall I just love the ease and productivity of working in python.

[So long, Guido, and thanks for all the fish!]

Wait, you're saying that if I put a brick on my accelerator and jump out of the car it's not doing autonomous driving? :)