The clean-code from andreisilviudragnea

DNS lookup fails
localhost DNS lookup succeeds
non-local DNS lookup succeeds, but port is unreachable
non-local DNS lookup succeeds, port is reachable, but unexpected service behind endpoint
non-local DNS lookup succeeds, port is reachable and expected service behind the endpoint

Check coverage of each separate unit test class

Tests inside the unit test class of a tested class should cover the whole tested class by themselves. This way, tests are decoupled too and the tested component can be easier moved.

Always assert everything about a test output

Use structured logging

Test resource safety in programs

Test all resources are closed: files, threads, network connections, KafkaProducers
Use resource-safe languages like Rust

Pay attention to concurrent cache initialization

It can block multiple readers when cache is empty.

Optimize code if only difference of values is needed

If only the difference between two function parameters is needed, use the difference directly as a single parameter.

Always ask yourself on which thread a lambda executes

Extract decision outside of loop

Do not over-abstract

In languages without modules, it is sometimes better to keep some implementation details as inner classes.

Pay attention to JSON special types representation in code

Use BigDecimal in Java, not double or int for JSON numbers
Use ZonedDateTime or LocalDateTime in Java for ISO8601 dates

Remove duplicated tests

Always test DNS lookup with something else than localhost domain

Separate data from behavior

Declare variables in the same order as they are passed to function calls

Merge two consecutive .map().map() calls

Two consecutive .map().map() calls on a Monad can be merged into one

Test disconnections and reconnections to services

Parse test input from human-friendly format

Prefer to parse test input from human-friendly format to make tests easier to write and understand

Test timeouts in unit or integration tests

Check copyright headers

Detect and remove redundant annotations

Use generic parameterized interfaces instead of defining new ones

Always use latest JDK version

Newer JDK can result in faster compilation times on Scala 2.13.8

Prefer iterator to manual iteration with index when only iteration is relevant

Use colorized output in CI environments

Reduce duplication in tests

Tests can easily introduce a lot of duplication if not written carefully

Always debug at interface boundaries

This is the fastest way to a bug

Inline recursive method with only one external usage

    pub fn num_trees_diff(n: i32) -> i32 {
        fn num_trees(n: i32) -> i32 {
            if n == 0 {
                return 1;
            }

            let mut sum = 0;

            for i in 1..(n + 1) {
                sum += num_trees(i - 1) * num_trees(n - i);
            }

            sum
        }

        num_trees(n)
    }

Refactor to dependency injection

Go to extremes with it. It will make your code better.

Replace String with pattern

Create strict unit test framework fork

Make Mockito framework strict
Fix non-strict tests automatically

Invert if condition

Always finish migrations

Add new code variant under feature flag
Enable new feature
Remove old code

Prefer static dispatch vs dynamic dispatch

Scala has simulated static dispatch in form of implicit parameters, whose value is usually known at compile-time
Rust has true static dispatch using associated methods

andreisilviudragnea / clean-code Goto Github PK

clean-code's People

Contributors

Watchers

clean-code's Issues

Recommend Projects

Recommend Topics

Recommend Org