NullAway VS Checkstyle

Would be cool if Java got this feature, explicit optionality at a language level a la T? is an enormous developer QoL in Kotlin and Typescript in my experience. In Java there's tools like NullAway [1] but they're a hassle.

Language-level support is leagues better than Optional/Maybe in my experience too because it keeps the code focused on the actual logic instead of putting everything in a map/flatMap railway.

[1] https://github.com/uber/NullAway

Fortunately, Uber made tooling for languages with broken type systems

* https://github.com/uber/NullAway

* https://github.com/uber-go/nilaway

Some patterns arise from language design

* You can't express `T` where `null` is forbidden in the type system so you get NullPointerException everywhere and defensive null checks.

* You express a sum type as a product type because your language does not have sum types .

* Your language doesn't have first class multiple return values (or tuples) so you return extra parameters via out parameters or thread local variables such as `errno`.

* Your language doesn't have exceptions (or algebraic effects) and can't do IO so you have monad transformers.

* Your language doesn't have set-theoretic types so you need hacks like `thiserror` .

* Your language doesn't have stackful coroutines or can't infer async IO for you so you have `async/await` spam or callback hell or "mono's".

* Your language doesn't have exhaustive checks (or pattern matching) so you need a fallthrough case check on switch statements .

* Your language doesn't have algebraic effects, so you need to pass context everywhere.

I know someone will reply about Java's null annotation checking options, so here is one of them: https://github.com/uber/NullAway .

If you must use Java, use Uber's Nullaway which gives null safety via Errorprone.

Does anyone have experience using this at Meta who can compare to https://github.com/uber/NullAway ?

A special kind of validation is enforcing that record fields are not null. (Un)fortunately, records do not have any special behavior regarding nullability. You can use tools like NullAway or Error Prone to prevent null in your code in general, or you can add checks to your records:

What do you think of https://github.com/uber/NullAway

Take a look at NullAway, a plugin for Error Prone.

PMD, Spotbugs, Nullaway: Java linting/static analysis (https://pmd.github.io, https://spotbugs.github.io, https://github.com/uber/NullAway)

We had a list of suggested code formation tools, as my code was written in Java I decided to use suggested formatter GoogleJavaFormat. However, I didn't decide to pick suggested tool for Linter. I picked Checkstyle; for the reason, that SpotBugs wasn't available for JDK 22.

Linting and Code Static Analysis: Stripe implements strict linting and code static analysis to maintain high code quality. Tools like Checkstyle for Java can be integrated into your CI pipeline to catch potential issues before they reach production.

I'm trying to use Google's checkstyle. I want certain things to be an error, such as using Tabs for indentation. When I run mvn checkstyle:check with a file with a tab in the first column, it always gives a [WARN] rather than the error that I've asked for. Pom snippet: org.apache.maven.plugins maven-surefire-plugin ${maven-surefire-plugin.version} ${maven-surefire-plugin.skipUnitTests} org.apache.maven.plugins maven-checkstyle-plugin 3.1.2 checkstyle validate check google_checks.xml UTF-8 true true warning true I'm using google_checks.xml as from https://github.com/checkstyle/checkstyle/blob/master/src/main/resources/google_checks.xml. I have changed the severity for the FileTabCharacter to "error"

1. Conflicts between Spotless and Checkstyle Checkstyle is a tool for checking Java source code for compliance with code standards or a set of validation rules (best practices).

Never had anything like that though for four years my life revolved around getting PMD, checkstyle and Sonar rules to pass so my pull request would merge.

PMD, and checkstyle as well.

I’m a little out of date with Java, but I believe Checkstyle is currently popular: https://github.com/checkstyle/checkstyle

Another example can be applied to code quality itself. Most static analyzers are configurable. If you tried to set Checkstyle Google configuration to the mature project, you would probably get hundreds or even thousands of errors. You can start with just one rule. Ar first glance, it seems not so important. But after the moment when the configuration reaches the repository, you can be sure that no one else can violate this rule in the future.