Theory. I think the confusion stems from using the same symbol to denote two different functions. If we denote addition by a, multiplication by m and inverse by i then the problem can be summarised as follows:

1. a and m are functions from K × K to K.
2. i is a function from K \ { 0 } to K.
3. When we see x / y we usually think of a function d(x, y) = m(x, i(y)) and this is a function from K × K \ { 0 } to K.
4. However, we can define a different function d’ from K × K to K such that the restriction of d’ to K × K \ { 0 } is d.

Using / to denote both d and d’ is what is causing confusion. Some people see 1 / 0 = 1 and assume it means 1 · 0⁻¹ = 1 (and I find this thought natural) but what is really meant is f(1, 0) = 0 where f could be d or d’ or something else entirely.

Here’s an unsurprising summary: You can define an arbitrary function f on a field and it won’t “break” the field in any way. You can introduce an inconsistency if in addition to the definition you add some claims about it’s properties that are related to the field but a definition alone cannot wreak havoc.

Practice. There are practical implications though. This whole discussion proves that there’s a lot of confusion over what the / symbol actually means. People assume it’s function d written using an infix notation. I think that making / denote d’ can be surprising to lots of people and cause them to introduce bugs.

If I see code like

if a / b == 0:
  ...

then it is natural for me to conclude that: a is zero and b is non-zero. In other words, it’s natural for me to think of function d and not of d’ or any other function. However, if / means d’ then my reasoning does not hold.

We can define / to mean anything we want, swap + and -, swap the meaning of digits, and do all sorts of syntactic changes without changing the meaning of these symbols. Computers don’t care but programmers do and this whole discussion is the best evidence that this change will cause lots of confusion.

Odd, because I didn’t read the XKCD comic as making fun of security people for saying ‘voting machines won’t work, stay away’ at all. I read it as saying voting machines won’t work and that we should stay away from them. And to that I have to say: I totally agree. Voting works fine as it is: done by humans, counted by humans, entirely on paper with not a computer or network in sight.

This is great! Are you aware of any desktop tools like that?

A few tips:

• Definitely read Working Effectively with Legacy Code by Michael Feathers. He shares many techniques that should help you start adding tests in small pieces.
• When rewriting a function run the old and new code and compare results (note isEqual can be implemented with === only for primitive types):

    function newFunction() { ... }
    function oldFunction() { ... }
    function tryFunction() {
      const newResult = newFunction();
      const oldResult = oldFunction();
      if (isEqual(newResult, oldResult)) {
        return newResult;
      }

      logMismatch();
      return oldResult;
    }

• Applied at a high level this technique can mean routing the same request to two instance of the same app and comparing the results on the fly - a sort of runtime golden master testing.
• Explain what you’re doing to the users. This will help you manage their expectations. Most likely, they’ll be happy to help you.
• Add the ability to deploy the code to each company separately to limit the potential damage.
• Make it easy for you to rollback a broken build. This will help you avoid embarrassment if you mess something up.

Computer science trivia: the halting problem is trivially solvable for finite-memory Turning machines. Proof: if you have b bits of memory then you can represent 2^b states. Load the program and step it 2^b + 1 times. If it’s halted then you’re done. If not then according to the pigeonhole principle there are two steps corresponding to the same state. This proves the existence of an infinite loop.

Unfortunately, I’m not aware of any tools that could help you prove the equivalence of two programs.

I was watching Rogue One and saw Grand Moff Tarkin, the commander of the Death Star, portrayed by the same actor as in A New Hope. What I found surprising is he looked exactly the same despite 39 years separating the two movies. It turned out the original actor passed away in 1994 and he was recreated using a computer! WIRED published a short video about that.

I absolutely understand the economic motivations behind this move. I’m concerned because it seems that if other smaller players do the same (migrate over to established players like Reddit) then it’ll drive more users to incumbent companies. Someone in the thread included a link to an instruction how to deal with GDPR trolling which I’m bookmarking right now just in case.

This reminds me of my assembly and reverse engineering days. On 64-bit Intels whole registers are referenced using RAX, RBX, etc. while EAX, EBX, etc. refer to the lower 32 bits. There are also 8 more general purpose registers named from R8 to R15.

I recommend reading the discussion in Redmine. It seems the rational is that Integer(string) rescue default_value:

1. is slower than Integer(string, exception: false) || default_value.
2. generates a lot of noise in debug mode.

I have mixed feelings about that.

These kinds of “Falsehood” articles often raise more questions than they (seem to) attempt answering. Take the last point for example

People have names.

What is this supposed to tell me? Why not at least link to some resource or source explaining the issue with suggestions for peoole who want to solve X-related problems. All I could conclude from this would to be just to forget about names beyond these just being metadata… or was that the point?

This reminds me of the probabilistic method in mathematics.

Hi Lobsters! This blog post is about Project Sistine, a hack that I worked on with @antimatter15, Guillermo Webster, and @loganengstrom. We turned a MacBook into a touchscreen using only $1 of hardware (a small mirror, some pieces of a rigid paper plate, and a door hinge).

We built this prototype some time ago, but we never wrote up the details of how we did it, and so we thought we should share. We’re happy to answer any questions you might have about the project!

If you want to avoid metaprogramming then I recommend setting up a snippet in your editor that expands to a memoized method. For example, when I type memo<TAB> (I use UltiSnips) then the following appears:

def name
  @name ||= value
end

UltiSnips keeps name in sync both in the method name and attribute name. Pressing <TAB> one more time takes me to value. You can of course do the same for the more bullet-proof approach described in the article.

Corporate before humankind..

Depressing that something so widely depended-upon (by companies with deep pockets, no less) can’t even keep the tests in the software renderer green. This is why we can’t have nice things.

Interesting findings. I might have missed something but did it actually establish causation? If less parameters and more tests tend to occur together then it might be the case that it’s easier to test methods with fewer parameters hence they’re tested more frequently. In general if A correlates with B then 1. A causes B, 2. B causes A, 3.there’s C that causes A and B.

Im curious what experimental design should be used to establish a casual link between testing and various code outcomes. Any papers you would recommend on the topic?

I did a talk about this called ‘The Deep Synergy Between Testability And Good Design.’ The case I made was that difficulty in unit testing often indicates design problems. I listed about 10 cases where that appeared to be the case. The crux of my argument was: writing tests is writing a program to understand your code. If it’s hard to do that, it’s probably hard to understand the code also.

I like this paper because it shows some real empirical correlation. The places where it fails are very interesting, particularly the cases of long methods and complexity. I suspect that testing enables complexity because tests allow us to write code that is ‘correct’ but still not easy to understand at a glance, whereas something like parameter count for methods tends to go lower because it’s extra work to write tests for methods with more parameters.

This space where the ergonomics of practice ‘nudge’ design is very interesting.

Great patching and write up.

Trying to save as much space as possible reminded me of my high school years. I was involved in the crack scene and tried to build the smallest crack template possible. I ended up putting assembly instructions in headers and jumping between them to save a few bytes more. I even managed to include the group’s logo. There’s also an article about producing the smallest possible ELF binary.

Is preact a viable alternative from a technical standpoint?

In think it’s clear at this point that anyone who takes mobile security seriously has to be using an Apple device. Samsung didn’t even respond to OPs outreach.

In my opinion electronic voting systems don’t make much sense because they’re opaque to an ordinary citizen (hence non-auditable) and optimize a tiny fraction of government spending. It’s a case of modernititis where it’s assumed that modern is by necessity better.