skysight-inc/HackerNews huggingface dataset:
So it's still not the problem that a machine can recognize you, but rather that somebody is tracking and storing such recognitions.

Which is an entirely different thing. The former is a technological reality. It's impossible to legislate away devices who can do that.

Tracking and storing personal data on the other hand, is very much within the reach of regulation. The GDPR for example restricts this. Even if somebody has devices who can recognize you is not allowed to store and track data about such recognition incidences without your approval. In this particular case, they don't need your approval because the camera is used in lieu of a boarding pass, and the airline has every right and duty to know you are boarding right now.

In case you are worried that the airline connects your travel patterns with other companies interested in other patterns, well, that works with a boarding pass or even a simple check mark on a pen-on-paper boarding list just fine.
Some people prefer a Python 2/3 community schism, others prefer that tools actually get adopted in spite of a few transition flaws.
Haxe has pretty good metaprogramming capabilities. It has expression macros (compile-time evaluated calls that return expressions to be inserted at call place) as well as type-building macros (build fields and/or define whole new types). Both have access to compiler and system API and information about the context (e.g. expected type).
Which features make it the most advanced?
Template Haskell is nice, but doesn't allow higher meta-programming, eg. meta-meta-programmming.
I just add "Julia" for this list;

Ideal for Scientific computing. ( LLVM based; Optionally typed; Dynamic )

https://julialang.org/

https://docs.julialang.org/en/v1/index.html

Julia Metaprogramming:

https://docs.julialang.org/en/v1/manual/metaprogramming/inde...

Julia: "Building a Language and Compiler for Machine Learning" ( compiling to GPU; TPU )

https://julialang.org/blog/2018/12/ml-language-compiler

"Why Does Julia Work So Well?"

https://ucidatascienceinitiative.github.io/IntroToJulia/Html... ( "Core Idea: Multiple Dispatch + Type Stability => Speed + Readability" )
Inside Erlang – Joe Armstrong tells his story (2014)
Even getting a passport in the states is a pain though. Getting an European passport felt like a well-organized formality, while even as a native born citizen getting my US passport felt almost adversarial.
Ironically, systems written in hardware 10 years older than PDP-11, thus with less resources, were written in safer system languages, go figure.
> Have you actually travelled on such a passport?

Yeah, I've travelled to Turkey pretty soon after I had it issued, in fact that was the main reason of me getting a passport and yes, I did sort of use it as a one-time thingie. It sure adds some extra costs (in real money and in opportunity costs) but I'm willing to eat them up, for the moment.

> is sure to attract attention from foreign authorities, they'll assume you're restricted for some reason. Telling them that you got it to avoid being fingerprinted is not going to please them.

That's one extra reason not to travel to countries that treat tourists/foreign people like crap.
Regular format to CSV, support for separator customization
Interesting, why do you advise people to stay away from Shiny?
Versioning Gitlab 11.10 controls merge request pipelines
Strange quirk! How do you even come across this?
https://pint.readthedocs.io/en/0.9/
Interesting to see performance difference comparing to 2 version:
https://github.com/krausest/js-framework-benchmark/issues/55...
True, but IIRC it's more of eliminating competition or maybe even a blood sport; sharks aren't major part of their diet[1]. Would make sense given that heavy metals and other toxins bio-accumulate up the food chain.

I posit the high heavy metal levels is a defense mechanism for sharks: a slow acting poison.

[1] IIRC again, orcas will leave a shark with the tail cut to just die of asphyxiation, somebody please correct me on this one
I dont know, its so confusing with so many options from Google.
That sounds terrible to me. I hope there is at least proper CI which executes stuff from the makefile, but even that, `scp` to ship something in 2019 is a step back (https://www.phoronix.com/scan.php?page=news_item&px=OpenSSH-...) .
Oh, and regarding "how compact are your programs", well every time I see boilerplate code or reflection usage that cannot be refactored into something nice without sacrificing clarity and/or performance, I use meta-programming to generate it instead.

Usual suspect here is any kind of "support" code, like serialization, RPC, dependency injection and such.
This was posted on HN yesterday.

https://news.ycombinator.com/item?id=19718344
I agree. Print is the most fundamental tool available to you: debuggers are kernel and hardware spanning monsters that introduce an external logic dependency. We don't advocate for more complexity than is necessary in other places.
> They didn't implement this shit.

Without the EU council - the assembly of the countries - saying yes there's no new law in the EU. Therefore, saying they didn't implement this shit is wrong. If they didn't want to, they could have stopped it. They also still can stop it if they want to. The vote of the parliament is not the last step. The council has to agree.

http://www.europarl.europa.eu/about-parliament/en/powers-and...

Apart from that most of the legislation that the commission initiates is done because the EU council asked the commission for it. So, the countries asked for this in the first place.
Compile-time MP and run-time MP. Support for AST and quasi-quote MP, and support for LMS (= lightweight modular staging).
Note: Haxe does not typecheck macros.

See https://haxe.org/manual/macro-ExprOf.html

For example, this seemingly ill-typed definition (which should return Int as suggested by the type paramater, but in fact returns a string) successfully typechecks:

class StringGetter {
public static macro function getString():haxe.macro.Expr.ExprOf<Int> {
var s:String = "";
return macro $v{s};
}
}
No reason to force everyone to be equal, just create your equality paradise and open the doors to the world.
Option "-l" only supposed to be used with text output. When mis-applied to binary (-w) output, it will:

- On Linux, flush buffer at wrong places, breaking last (few) packet(s);

- On Windows, flush buffer after every byte (which gives acceptable result, but is very inefficient).

With "-w", always use "-U" instead.
Thanks For sharing this information. It’s Nice..!!!
https://games.lol/
This is a great post. I like this topic.
https://games.lol/
In an effort to be as unproductive and productive as I could, I built a robot once that just pressed the 5 button on my mousepad avery ~1.2 seconds or so. This let me, over the course of 30 days of straight button pressing, successfully accomplish a goal in a video game without triggering their macro detection. It also burned out a few LEGO motors and gears, but that's a minor thing to pay for not having carpal tunnel.

But to actually answer your question, I have a mouse set up with a few macro buttons. One is alt+tab and the other is alt+tab+tab, which lets me switch between the last 3 visited windows very quickly. Usually I'm using it to switch between a project program and its documentation. The last one is bound to windows+lshift+s, for quick screenshots.
Quantity has a quality all its own, as they say.

If you live in a town and there’s a couple security guards or even cops that can recognize you, that’s pretty normal.

If there were thousands of private security guards as well as cops hired by the government stationed all around you, in every part of your life, gazing at you from every corner, and they had all been trained to recognize you, and every time you walked by one they whipped out a notepad and took detailed notes on what you were doing, you’d freak the fuck out, justifiably.
A Blockchain Experiment with Apache Kafka
Reminds me of a similar issue with Crucial M4 SSDs failing after 5,200 hours which also required a firmware update.
In the case of the boarding situation, there are too worst-case scenarios: One being the system doesn't recognize a valid passenger, then he does have to show his boarding pass or another passport.

Worse would be accepting someone who isn't allowed to board, but such things are easily mitigated.

The potential to be mistaken for a wanted criminal has always been real. Facial recognition may even be more accurate overall in that regard. But it's nothing new. Drug sniffing dogs have false alarms all the time, some even cheat intentionally. And police officers better not shoot someone on sight when they recognize them from a mugshot.
Because violent upheaval has such a fantastic history of consistently returning liberal governments that are not at all interested in security measures?

Going to go out on a limb and say that preferring to be biometrically screened at an airport than incarcerated or dead isn't an irrational phobia of the latter either...
This is solved in Rust by letting you test and unwrap at the same time:

if let Some(obj) = my_optional {
do_stuff(obj);
}

>However if the dereferencing, my_optional, should be safe, it too would need to perform a conditional check behind the scenes. But it doesn't - as C++ places that on the programmers hand to not sacrifice speed

So basically that turns C++ optional types into fancy linter hints which won't actually improve the safety of the code much.

I understand C++'s philosophy of "you pay for what you use" but that's ridiculous, if you use an optional type it means that you expect that type to be nullable. Having to pay for a check is "paying for what you use". If you don't like it then don't make the object nullable in the first place and save yourself the test. That's just optimizing the wrong part of the problem.
Go has garbage collection support, so it's definitely more convenient in some specialized domains than Rust - namely, those which inherently involve spaghetti-like allocation and "ownership" patterns that RC alone can't deal with very well. You wouldn't want to rewrite a typical LISP codebase in Rust, but with Go you could make it work and get good performance out of it.

(You could of course use a ECS-like pattern in Rust and end up with a half-baked reimplementation of a Go or LISP runtime, but the ergonomics would not be there.)
I've made a simple script based on your example:

wirelive.sh:

#!/bin/bash

if [[ -z "$1" ]]; then
echo -e "Usage: $(basename $0) <host[:port]> <interface> [filters]"
exit
fi

ssh_host=$(echo $1 | cut -d: -f1)
ssh_port=$(echo $1 | cut -s -d: -f2)
[[ -z "$ssh_port" ]] && ssh_port=22
[[ -z "$2" ]] && tcpdump_interface="any" || tcpdump_interface="$2"
[[ ! -z "$3" ]] && tcpdump_filters="and \($3\)"

ssh root@${ssh_host} -p ${ssh_port} \
tcpdump -U -s0 "not port ${ssh_port} ${tcpdump_filters}" -i ${tcpdump_interface} -w - \
| wireshark -k -i -
Basecamp: All-Hands Support
There are many countries where Amazon is out competed by local companies that simply sprung up earlier.
Shaving is both not a necessity and something people of every gender do equally.
That's not entirely true. `ExprOf<T>` itself is not checked in either the macro function argument or return type, but that's only meant for static extension (and maybe some other features?).

Expressions generated by your macros will be parsed by the type checked. You won't be able to do

var s:Int = StringGetter.getString();

Because you'll get a compilation error there (http://try-haxe.mrcdk.com/#48EDb).
Adalm-Pluto SDR
Agree, although there are still many incredibly active forums around, but I do feel the golden age of them has passed. I started my career on forums, modifying them, moving eventually on to more general web work. It makes me a little sad to think this is pretty much the only "forum" I post in, but even HN is algorithmically-biased :)
Graph Convolutional Networks (2016)
Ok, I accept that Vox is not the best source of information on this matter. Here is a compilation of studies where the author has tried to include either peer-reviewed studies or reviews of data that tend to speak for themselves and don’t require much statistical analysis. he notes that most (but not all) of these studies do factor in variables that address common claims such as that the criminal-justice system discriminates more by class than by race, or that racial discrepancies in sentencing or incarceration can be explained by the fact that black people commit more crimes. And he's also included a section for studies that do not find bias in various aspects of the criminal-justice system. There are far fewer of these, though he is open to the possibility that he missed some.[1]

[1] https://www.washingtonpost.com/news/opinions/wp/2018/09/18/t...
Natural Language Processing Techniques
Linux Performance Tools (2015)
Suspicion Grows over Dark-Web Market's $30M Crypto Theft
Facial recognition systems are everywhere, even in Poland small shops(FreshMarket, etc.) have it built into cash registers.

Is this something that concerns me? Absolutely not and I can even say I don't give a fuck. Most of the government institutions already have your photo, signature, and many more from ID/Passport or any other government documents you made. So why you should be afraid of companies who does it too? I know, I know, privacy, ads, tracking and stuff. :)

But is this still fight for privacy? I see many startups us this rhetoric to acquire clients. But it turns into a terrible joke like it was with usability 15 years ago. Where companies offered services that were not needed to collect even more money.
When I hear metaprogramming my brain just goes "Lisp". So I am a bit surprised to not see CL in your list. :)
Sure, and those other governments just fell on the wrong button. Complete distortion of the current political landscape.

edit: ... and legislative process.
I tried it some months ago. It was rough around the edges: I tried to mount two videos together (a speaker on one side and a bunch of slides on the other). I found the interface unintuitive, and the speed was daunting.
OK, sure.

But consider how reckless Apple was. Reportedly they had some store video showing thefts by someone with a particular facial feature hash. And I'm guessing that they also linked that hash to a non-photo ID. Which are easily counterfeited.

So say they had stopped there, and called the police when someone with that hash walked into a store. That would be bad enough, given how unreliable facial recognition is.

But they went further. They had this kid arrested, relying on doubly unreliable information. That's what's reckless, and why they should be punished. If for no other reason, to set a precedent.

So in a way, the actual risk that the kid faced is irrelevant. What matters is what might have happened.
Dont think it works, tried few examples, it throws NotImplementedError at me all the time. Any hint?

~/anaconda3/lib/python3.7/site-packages/pysnooper/tracer.py in get_source_from_frame(frame)
75 pass
76 if source is None:
---> 77 raise NotImplementedError
78
79 # If we just read the source from a file, or if the loader did not

NotImplementedError:
> Haxe does not typecheck macros.

That is a weird statement. Haxe expression macros by definition return untyped AST to be processed further normally by the typer, just like hand-written code. And it will be type-checked. And then there's an AST node existing exactly for type-checking (or, rather, type unification) that you can generate to insert custom checks: https://haxe.org/manual/expression-type-check.html
My local ICA supermarket has three or four brands of cup alone.
I like the Python-way, which allows to iterate over permutations and combinations without generating everything upfront.

https://docs.python.org/2/library/itertools.html
I think it was when the wartime id cards where up for renewal the civil service wanted it - but parliament thought it smacked to much of "Gestapo" as Churchill put it.
You could fly with guns and smoke cigs in planes in the 50s-60s, that was true freedom, right ?

Planes were hijacked all the time, and back then they weren't nearly as many planes as now. [0]

> so much of what made air travel fun

It's not supposed to be "fun", flying isn't a right, it's a privilege that enabled mass tourism which is an ecological and cultural plague. People take easyjet/ryanair like they take their cars to go grocery shopping, Berlin, Paris, Rome, &c. are now hell on earth.

[1] https://en.wikipedia.org/wiki/List_of_aircraft_hijackings
Seeing how many O(n^2) he found, I think you could've stopped your sentence at tested.
I like Berlin Tegel, but Berlin Schönefeld always seemed to me to be its low-budget brother.
And you'd justifiably tell them to not do it...

And if you are not able to stop them from doing that, may I suggest you have a bigger problem with your government or the security guards than being tracked by them?

Again: Tracking personal data is regulateable, facial recognition technology is not.

And the mere act of checking the identity of a person for legitimate access control purposes is no unreasonable infringement on privacy.
F# has units of measure. A frontend is (usually) not F#, but even for a more loosely typed system such as your typical web frontend, it should be possible to represent scalars as tuples of a number and an identifier. Eg. { qty: 12, unit: "kgs" }.
F# has this:
https://fsharpforfunandprofit.com/posts/units-of-measure/
> You really can only do advanced meta-programming using functional techniques.

My `loop for (symbol value) on bindings by #'cddr` and "push onto list in a loop, nreverse and return at the end" macros beg to disagree.

Metaprogramming is just like any other programming, except that the output is fed to the compiler. The way Lisp is compiled, you can even use code generated by code in code that generates other code.

That said, functional programming does indeed fit well with most of the stuff you do when writing code that writes code.
I used a Youtube tutorial. Unfortunately, I can't for the life of me remember which one it was. I think you can probably just watch a few and then start editing some video. What I found was that there were little, "Oh wow. That is so efficient" kind of moments and because the were surprising I found myself remembering them. By far the most difficult thing is configuring everything at the beginning, though. If you aren't familiar with Blender, it's just baffling. IIRC I ended up surfing a lot of different videos suggesting ways of setting things up and just tried all of them. This gave me some familiarity with how it all worked. I remember setting the video speed to 0.25 and paying attention intently to what they were doing :-). Usually I hate video for learning stuff, but for some reason with Blender it worked for me.
Well I blame Apple for this. Why? Because they obviously had video of the real thief and there is no excuse that they could not have compared the results of the two before notifying the police let alone have the system immediately of facial recognition know they aren't the same people visually.

If anything I want to know, does the store record anything outside its physical interior? What is the retention of this data. What is the process and safeguards before a situation like what just happened? Who makes the final decision? Are your images tagged each time you use your ID for any engagement within the store? Heck, do they even post notices they do this?

For a company that touts privacy they really blew it and in a spectacular way
>UK is 242,495 km2

And 2249 TWh / 8 GWh = 281,125

>Also lots of wind parks are off shore where there’s less vegetation and hills to slow down wind.

They're more expensive to construct and tear down after. They do generate more power, on average, but in these calculations with average it would only give you a ~20% advantage.
I use Common Lisp for its really insane metaprogrammability (reader macros, compiler macros, ordinary macros, and the MOP to edit the object system) and the ability to bend to the problem that I am trying to solve. It has decent interoperability via its CFFI interface.
> Not to mention having to delay an update notification daily on my Mac.

I don't understand this. Windows is "dragged over the coals" for forcing updates at the worst times. Why? Because no one ever updates willingly, the update just gets kicked down the line until finally the system forces it.

You have two options for osx:

* Complain about update notifications and never change your attitude or flow. Continue to gripe on forums instead.

* Understand that updates are generally good, and run the updates in the morning before you start working, or at a more convenient time.

I only push back updates about 2-3 days if I forget, but it's not that hard to just update and get it over with.
CL doesn't have hygienic macros.
I think corporal punishment along with money would be great as punishment when it comes to corporations/rich people. Maybe only for the next 5-6 years, just enough to clean around.
So lazy evaluation, really. This can help tame some instances of combinatorial explosions if you can filter the result enough before you concretize the result, but if you’re not careful you’ll end up in a long loop just like you would with an eager method.
Incorrect. To quote the page you've linked: "For the most part, this type is identical to Expr, but it allows constraining the type of accepted expressions." or otherwise put: ExprOf only affects macro arguments, not return value. What you want is this:

class StringGetter {
public static macro function getString() {
var s:String = "";
return macro ($v{s} : Int);
}
}
It also allows for more abuse, because the weakest link determines that.
Serious question here: how does this compare to what Google did in the Oracle vs Google java api copyright case?
Grantparent above literally said it's a goal.
You haven't seen any Lisp yet, have you?

Compile and run-time MP and quasiquoting are basic features; I'd argue that a language without these doesn't even qualify as "supporting metaprogramming".
Only if the software patent is really an innovation, not just restating something already known in a different way.

Patents need fixing from both ends - the enforcement end for non-practicing entities, as well as the assignment end, where patents are examined under harsher conditions.
Virtualization can help reduce the harm caused by a misbehaving program but it won't magically make the program behave correctly.

Having a program cause a memory violation and be killed by the OS is the best possible outcome in this case, it stops the program from doing any damage and you get a clear symptom of the problem for debugging.

It's when the issue is not that obvious that you're in real trouble because it may start behaving erratically, corrupt data and be exploited by malicious actors to get access to resources that shouldn't be exposed.
Wouldn't be surprised if they soon move to track everyone's DNA and we will be living in a "Brave new World" future.
Wow, A thousand thanks for this.

Another one of those Discover and Distribution problem I encounter. How can I not know this exist.
I had a similar situation last November, when an over-eager Lufthansa check-in officer denied boarding the plane because I was using a Finnish national ID card. I was travelling from Finland to Croatia and the explanation was that Croatia had enabled passport checks on border and ID card is no passport.

No amount of explanation helped. I did have my passport with me and I showed it to this lady. Rest of the trip I used only the ID card.

Common theme seems to be, at least in Finland, that dealing with public agencies and authorities is just fine, but you can get to a trouble with private companies.
Zuckerberg’s password in June 2016 was “dadada”. That’s about as successful an attempt at privacy as the average person :)
Cool, I wasn't aware of Scala's LMS. Thanks for sharing!