error-prone

This article seems like a very long-winded and complicated way to say that we should write tests. Am I missing something here? Wouldn't most developers write tests when creating algorithms, let alone something relating to finance as tax calculations? Yes, you should reproduce a defect by writing a failing tests first. Where I hoped/thought this piece would go was to expand on the idea of error-prone[1] and apply it to the runtime. https://github.com/google/error-prone

- It doesn't work with ErrorProne (https://github.com/google/error-prone/issues?q=sort%3Aupdate...) - you need a special plugin in your IDE for the generated classes to be visible and/or the code to be parsable - it does not work with many other tools, usually there is a bridge to fix that, e.g. with MapStruct: https://mapstruct.org/faq/#Can-I-use-MapStruct-together-with... Other tools and libraries generally do not interact in such an errorprone manner. That said, when you know how it works, what it needs, and you know how to iron all of those tiny wrinkles, it works fine and saves you some code and/or sanity. It's not the devil, it's a powerful tool with some downsides.

Big tech uses static analyzers a lot. See for example, these projects: - https://fbinfer.com/ (<- This one was a breakthrough in static analysis in its time) - https://github.com/google/error-prone - https://github.com/facebook/SPARTA And many others

For some of this stuff, there are compiler extensions that allow extra type checking to be added e.g. Google Error-Prone: https://github.com/google/error-prone with stuff like: https://errorprone.info/bugpattern/ReturnMissingNullable. Doesn't help you with third party libraries, but across an org applying that rule (and others!) typically ensures some consistency.

ErrorProne has a nice safeguard against this if you're writing Java code: https://github.com/google/error-prone/blob/master/docs/bugpa... It detects if your function signature is > foo(first, second) and you call it with > foo(second, first) that is, it actually checks for variable names that are mismatched, with comments like > foo(/* first= * / second, /* second= * / first) as an escape hatch.

Error Prone is not internal: https://github.com/google/error-prone

Google's ErrorProne, https://github.com/google/error-prone/tree/master/core/src/m... Bill Pugh's FindBugs, http://findbugs.sourceforge.net/bugDescriptions.html

Technically, it's not a compiler plugin - it actually replaces javac by extending JavaCompiler, wrapping it and applying additional verifications without altering the output. Effectively it's introducing its own API for compiler plugins, with those being the checks, very much akin to APT. See https://github.com/google/error-prone/blob/master/core/src/m... for the entry-point. I'm very close to getting out of my depth here though :)

Google error-prone is a good alternative to FindBugs: https://github.com/google/error-prone http://errorprone.info/bugpatterns Pros: * has faster cycle times and integrates into compilation workflow * emits fewer false positives * active maintainers fix issues * releases several times per year Cons: * FindBugs has a greater breadth of checks * current error-prone releases only work with Java 8