dylint VS wasmtalk

There is also https://github.com/trailofbits/dylint for writing custom lints.

Apart from clippy (which uses rustc-internal APIs), there are two other projects which can be used to implement lints: rust-analyzer can be extended with more diagnostics, and dylint provides an interface to run custom lints for Rust.

RE: Program is a model

There are some more advanced refactoring tools now available. These tools enable you to write code to detect bad code patterns and even automatically fix them. You can use them to write one-off transformations of code too. Rust has Dylint [1] and C# has Roslyn Analyzers [2]. Facebook has tooling [3] that helps writing CodeMods, enabling authors to generate changes for thousands of files at a time.

The thing I really would like to see is a smarter CI system. Caching of build outputs, so you don't have to rebuild the world from scratch every time. Distributed execution of tests and compilation, so you are not bottle-necked by one machine. Something that keeps track of which tests are flaky and which are broken on master, so you don't have to diagnose spurious build failures. Something that only runs the test that transitively depend on the code you change. Automatic bisecting of errors to the offending commit.

[1] https://github.com/trailofbits/dylint

[2] https://docs.microsoft.com/visualstudio/code-quality/roslyn-...

[3] one example: https://github.com/facebook/jscodeshift

If you're looking for something like clippy but with custom lints, there's also dylint -- it is clippy, but with support for running dynamically loaded lints across multiple versions of Rust.

You might find dylint useful! It's exactly that: a tool to run custom clippy lints.

Dylint. A tool for running Rust lints from dynamic libraries.

I've had very similar thoughts and have wrote about them here. I would be interested in discussing more.

https://github.com/brennancheung/wasmtalk

Some key takeaways from the above link:

- The programmer's tool should be a tool for manipulating an annotated AST (not text)

- There should be many different types of UX's for different scenarios, each maps to and from an AST in a UX that is optimal for the developer for that scenario

- We must be conscious of human brain limitations and cognitive psychology and work within those constraints

- "Reading" and "Writing" code should have different UX's because they are radically different use cases

- Use RPN. It models the real world. Humans are designed to manipulate their environment in an incremental manner seeing the result each step of the way. When we have to plan out and write code for an extended period of time, trying to play compiler in our head, we overload our brain unnecessarily and highly likely to make simple mistakes.

- Testing should be a first class citizen in the developer experience and indeed baked into how we develop at a fundamental level that it seems strange that they are even decoupled to begin with.