checkers | Classic board game implemented as C console application | Game Engine library

The issue you are talking about is called "Duck Typing". You can find more information about it by Googling the term.

Python explicitly allows duck typing. If an object has a swim method, then you can call swim() and hope that it does the right thing.

One of the jobs of a linter is to protect you against duck typing. If you're saying that a method accepts a Duck, then the type checker's job is make sure that you only pass it an instance of a Duck. Sure, you can pass it an instance of a Whale, and that whale also has a swim method. But what happens when you later decide you want your duck to fly()?

The solution to your problem is Protocols. You might have a protocol Swimmable indicating that the object has a swim() method. Then your method makes it argument type be Swimmable.

In short, the linter is doing its job.

With help from nicojs, I was able to get basic Stryker functionality working on my library project.

As it turns out I was missing some critical configuration.

I was able to set the testRunner as karma. I added karma.ngConfig.testArguments.project and disableTypeChecks values in stryker.conf.json

You need to memorize and manage the selection of a piece. You can do it by:

Your code is almost right. __name__ is your friend.

According to the Official Python3 Documentation, there exist a couple of "Built-in relevant read-only attributes".

You will notice that if you make a small modification to main.py it will work fine (see below).

When you manipulate the DOM, the operation itself is syncrhonous but the browser decides when the user will actually see the changes. Sometimes, the broswer will not have time to redraw before the prompt appears. To get around this, you can wrap the alert in a setTimeout() to delay the alert.

Add option returnfig=True to mpf.plot to have it return fig, axlist.

There are strings with mistakes in natgateway.tf. The corrected version is:

EqualsVerifier uses Objenesis to create instances of classes, and it keeps the same reference of the objenesis object around for performance reasons. It caches all the objects it has created before, so that makes things quicker when you want to create the same object over and over again, which EqualsVerifier tends to do.

However, EqualsVerifier keeps a static reference to objenesis, which means that it lives as long as the JVM does. It turns out that the Quarkus test runner can re-run the same tests again and again, and it creates a new class loader each time. But part of the equality of java.lang.Class is that the classloader that created the class, must also be the same. So it couldn't retrieve these objects from its cache anymore and returnd instances with classloaders that are now different from the other objects created in the test, and this caused the exceptions that you saw.

In version 3.8 of EqualsVerifier (created as a result of this StackOverflow post), this issue can be avoided by adding #withResetCaches() like this:

The only thing that comes to my mind is that Isabelle/HOL can replay SMT proofs (as produced e.g. by Z3 or CVC4), e.g. involving integer and real arithmetic. For computer algebra systems, I don't know of any comparable examples.

The problem is that computer algebra systems tend not to be set up in a way where they can output a detailed certificate for their simplifications – if they were able to do that, one could attempt to replay that in a theorem prover. But it would have to go beyond purely equational reasoning, since many rules (such as your example) require proving inequalities as preconditions.

If computer algebra systems were able to output a trace of their computations as a list of rewrite rules that were used, including how to prove each of their preconditions, one could in principle replay such a trace in a theorem prover – but that would of course require that every rule used by the CAS has a corresponding rule in the theorem prover (this is roughly how replaying SMT proofs works in Isabelle). However, I do not know of any projects like this.

There are, on the other hand, various examples where CASs are used to compute some easily verifiable (but hard to compute) result, e.g. factoring a polynomial, isolating the roots of a real polynomial, Wilf–Zeilberger witnesses, and then verifying that this is really a valid result in a theorem prover. However, this does not involve certifying the computation process of the CAS, just the result.