Blog
  • devcrisis
  • ๐Ÿ”ฎSoftware atoms
    • Validating code Architecture with dependency cruiser
    • Actionable ways to use ChatGPT
    • Most courses aren't worth it
    • SQLite isโค๏ธ
    • Stabilizing Tests without fixing them
    • Interviews should copy Advent of Code
    • Rust is nice
    • Agile fatigue is rising
    • Documentation is needed after all
    • The Direction of the JS ecosystem is good
    • Zero configuration == <3
    • Make small pull requests
    • Good practices fade out
    • Rushing !== unmaintainable
    • Commit message readability
    • Universal Practices
    • More functions == good
    • Mocking Private Functionality
    • Lines of code != feature count
    • Different Software - Different Quality
    • junior2mid
    • Book alternatives
    • Courses
    • Type Driven Development
    • Latest and Greatest
    • Real Developers
    • 10x Developer
    • Books for beginners 1
    • Parkinson's Law
    • nest-cli architecture is nice
    • Incremental Feature Delivery
    • Self Healing Software
      • Typed Configuration
  • ๐Ÿ’กMemos
    • 2022 Holiday code report
    • Complexity
    • Software Development Fundamentals
  • ๐Ÿงฑfoundation
    • Junior2Mid
    • Books and resources for new developers
    • ๐Ÿ”๏ธNow
Powered by GitBook
On this page
  1. Software atoms

Lines of code != feature count

PreviousMocking Private FunctionalityNextDifferent Software - Different Quality

Last updated 2 years ago

One of the team (not personal!) acomplishments I am most proud of is when the line count stays relatively the same as more features are added.

This is a fundamental example of how software should be built iteratively.

Make it work. Make it right. Make it fast.

When you shape a feature it is easy to get it right if you allow yourself more freedom on the aproach. Fast feedback, but sub optimal quality. With tests you can easily refactor.

Once it is done it is much, easier to find logical duplication, fake data structures or types, etc.

Let's take an example project:

The first thing you will notice is the steep fall of line count. This was done via moving to a monorepo and abstracting the shared components. In a sense the steep line was dublicated code even though it didn't always trivially look the same.

The more important part though is here:

The code goes up, but it also goes down.

This shows the continued effort of the team to keep things lean.

๐Ÿ”ฎ
Linecount for a project over the period of 9 months