the-alchemist
Joined 8 years ago
Joined 8 years ago
Choosing Clojure6 and Datalog7 was a calculated risk–but one which paid off. The Datalog model offered the simplest and most ergonomic queries, had strengths in graphs and relationships, and the entity model could easily transform to more standard formats. In–memory Datomic was chosen on the server, allowing complicated relational rule–based queries to map over tens of thousands of claims, linking sources to the attributes of entities. Using Clojure allowed for rapid prototyping and fast feedback cycles. Together, this allowed constructing arbitrary graph traversal queries, without having to round–trip from the database to execute recursive code, allowing the nature of traversing the domain model to be separated from the specifics of the relationship. How entities relate, and how relations work through time, could be developed as separate concepts. Using Datalog queries, it was possible to get every subordinate, as well as the time ranges they held true for, with a simple query like (subordinate-of ?a ?b ?start-date ?end-date)
GraalVM is the SOTA in the JVM world for this.
Here's an oldish blog on this: https://chrisseaton.com/truffleruby/seeing-escape-analysis/
I'm sure PEA is better now, but it's not sure if it's moved beyond scalars (int, float, etc.)
1. One of the underlying cryptographic principles is multi-party / secure-party communication (https://en.wikipedia.org/wiki/Secure_multi-party_computation). e.g., three people want to share their salaries to each other, but don't want the information to be traceable to back to the source.
2. Another is Steganography, hiding text in, say, an image, or audio.
3. You want to prevent the problems with Signal, Tor, Bitcoin, etc. This means, no "50%" problem like Bitcoin, no monitoring of exit nodes like Tor, no centralized distribution issue like Signal.
Imagine:
Alice "sends" a message to Bob by creating an account on Reddit and posts a cat meme which has the hidden text (steganography).
Bob knows how to find the text in that cat meme, and responds by posting something on Twitter, which Alice can read and decrypt.
All this is deniable (I didn't get anything from Alice!), available (e.g., Twitter goes down), and secure.
The basic idea, AFAICT, is that _federal_ law should not punish _state_ crimes under this specific section of the law (§666). As noted elsewhere, there might be other laws on the books for bribes, but §666 doesn't apply here.
The distinction between "gratuities"/ "gifts" and "bribes" is artificial to me, as a normal person, but I understand that the law makes a distinction.
I'm sympathetic to the federalism argument (every state should have anti-bribery laws so that _states_ themselves can take them to court instead of waiting for the feds!).
But I don't understand why someone would explicitly write a law that tries to draw a fat line between bribes and gifts. Is that the legal equivalent of a bug? A bad law?
First, NY Post is kind of a tabloid. You gotta dig deeper. Here's the actual study: https://uk-air.defra.gov.uk/assets/documents/reports/cat09/1...
I recommend reading it. It's actually pretty well done.
Secondly, the report itself and common sense dictate that regenerative braking on EVs (or hybrids) greatly decrease brake usage, therefore brake dust. Some EVs have "one-pedal" modes where you don't use the brakes at all in normal usage.
Thirdly, tires is a different calculation. This looks like a fairly unbiased source (https://www.emissionsanalytics.com/news/2020/1/28/tyres-not-..., https://www.nokiantyres.com/company/news-article/there-is-a-...).
Looks like tire issue is a toss up, and it depends on what the type of tire and how you drive. The much higher torque on an EV and a heavy foot will wear down the tires a lot more, but that has more to do with driver behavior than EVs.
Also, this whole issue is kind of a red herring because tractor trailers and heavy pickups and SUVs are a much, much larger source of brake and tire dust, and overall particulate pollution.
Imagine if gcc could automatically, by default, download some shared library and include it in the build because of a special macro included by a random header file on the system.
Of course, this change is optional (just add `-proc:full` to the command line) if you want the old, less secure behavior.
Also, Lombok is not affected because it's not an annotation processor. (Also, look at Immutables: https://immutables.github.io/).
The most popular annotation processor that I've seen "in the wild" is the Hibernate Metamodel Generator (https://hibernate.org/orm/tooling/).
Also, Immutables (https://immutables.github.io/), my favorite Lombok alternative, is affected.
Of note, you can bypass this more-security-concious approach by just passing `-prof:full` to javac.