Archive for December 21, 2021

Tuesday, December 21, 2021

Four Years Without Net Neutrality

Nathan Leamer:

Four years ago today the FCC rightly repealed #netneutrality regulations.

And guess what? The Internet works fine.

But never forget the hyperbolic predictions. Thread below

Karl Bode (tweet):

This week a coalition of infotainment outlets, including Fox News, The Hill, Reason, and the Washington Examiner all pushed stories with the same underlying narrative: four years ago net neutrality was repealed and the internet didn’t explode, therefore repealing net neutrality must not have mattered. The narrative also bumbled around Twitter thanks to former Ajit Pai assistant Nathan Leamer, who now works for Targeted Victory, a DC internet comms and policy shop whose members have (surprise) telecoms like AT&T as a client.


One reason big ISPs haven’t behaved worse in the wake of the repeal isn’t because the rules didn’t matter, it’s because of the states. The courts ruled that the FCC’s attempt to block states from protecting broadband consumers was a gross over reach. In response, several states (like Washington, Maine, and California) passed replacement state level net neutrality laws ISPs weren’t keen on violating. Large ISPs were also nervous about the return of net neutrality rules on the federal level (yeah, the threat of regulation can be nearly as much of a deterrent as actual regulation) so they generally tried to avoid stupid stuff that was too ham fisted: like blocking entire websites or competitors outright.

Granted the nation’s biggest ISPs still engaged in net neutrality violations, they just had to be quieter and slightly more clever about it. That often involved imposing gatekeeper barriers, then trying to sell consumers and policymakers on the idea they were exciting new value propositions. Like AT&T imposing arbitrary and unnecessary broadband usage caps, then using those caps to disadvantage streaming competitors. Or CenturyLink briefly blocking internet access to sling ads. Or Verizon charging you extra to stream HD video. Or Sprint trying to charge its subscribers extra just to enjoy music, video, or games.

Nick Heer:

Many tweets about 2017’s coverage of the end of net neutrality rules were clearly inaccurate and hysterical — that is for certain. But the loss of those rules has not magically solved U.S. broadband problems, either; on the contrary, it has exacerbated the worst tendencies of telecommunications conglomerates as many people — including yours truly — predicted.


Ribosome Inverts PhotoDNA

Anish Athalye (via Hacker News):

Microsoft PhotoDNA creates a “unique digital signature” of an image which can be matched against a database containing signatures of previously identified illegal images like CSAM. The technology is used by companies including Google, Facebook, and Twitter. Microsoft says:

A PhotoDNA hash is not reversible, and therefore cannot be used to recreate an image.

Ribosome inverts PhotoDNA hashes using machine learning.

This demonstration uses provocative images to make a point: rough body shapes and faces can be recovered from the PhotoDNA hash.


SectorLISP: Lisp With GC in 436 Bytes

Justine Tunney (Hacker News):

The SectorLISP project has achieved its goal of creating a LISP that’s tiny enough to fit in the master boot sector of a floppy disk. To the best of our knowledge, this is the tiniest LISP to date. Since a master boot record is only 512 bytes, that means LISP is now tied with FORTH to be the most lightweight high-level programming language in the world.


One of the most important code size saving techniques has been to avoid the temptation of defining data structures in such a way that NIL is encoded as zero. For example, if the lowest bit of a word is a flag bit for telling atoms apart from cons, then that bit must be 1 for cons cells since NIL is an atom. In that case, all words representing cons cells effectively become a misaligned pointer and extra code needs to be written so the 1 bit can be cleared before addressing memory. Avoiding those address calculation woes by defining atoms as oddly-numbered words is far more profitable than avoiding explicit NIL compares.

Justine Tunney (tweet, Hacker News):

There’s been many changes over the past few months that made it possible to shave away another hundred bytes from the i8086 assembly implementation. It left plenty of room to add a 40 byte garbage collector.


It works by saving the position of the cons stack before and after evaluation. Those values are called A and B. It then decreases the cx cons stack pointer further by recursively copying the Eval result. The new stack position is called C. The memory between B and C is then copied up to A. Once that happens, the new cons stack position becomes A - B + C. The purpose of this operation is to discard all the cons cells that got created which aren’t part of the result, because we know for certain they can’t be accessed anymore (assuming functions aren’t added which mutate cells).


Similar to how a Chess game may unfold very differently if a piece is moved to an unintended adjacent square, an x86 program can take on an entirely different meaning if the instruction pointer becomes off by one. We were able to use this to our advantage, since that lets us code functions in such a way that they overlap with one another.

Infinite Recursion in Log4j 2.16

Ross Cohen (via Hacker News):

If a string substitution is attempted for any reason on the following string, it will trigger an infinite recursion, and the application will crash: ${${::-${::-$${::-j}}}}.

This is fixed in Log4j 2.17.


So, let me get this: Log4j is disabling JNDI, fixing various string substitution issues and who knows what else, but the root cause of the whole mess - that Log4j attempts string substitution on the actual parameter values remains untouched?

That is weird, but presumably changing it would break a lot of stuff. However, this article makes it seem like simply injecting into one of the parameters is not sufficient to trigger the infinite recursion, depending on how the logger was configured.

The scary thing is that I doubt that Log4j is unusually buggy. It’s just that more people are scrutinizing it now and finding these latent problems.


How to Find Why a SwiftUI View Is Updating

Luca Bernardi (via Dave Verwer):

SwiftUI has a new, pretty cool, debugging utility to help you understand what is causing a view to be reevaluated.

Call Self._printChanges() inside the body of a view to print out the changes that have triggered the view update.

Tim Wood:

This has been helpful a couple times already -- thanks! But unfortunately it seems to have some rough edges and can report false positives (FB9184397, FB9090652) in the latter report still evaluating the view when there are no changes (currently a big perf problem for us).

Paul Hudson:

[It] should be called inside the body property. This means you will temporarily need to add an explicit return to send back your regular view code.

To demonstrate this method in action, here’s some sample code where a view relies on an observable object that randomly issues change notifications: