Tim's Wiki

Software Engineering Practices

Properties2
descriptionSynthesis of design principles, algorithmic thinking, testing habits, and foundational engineering judgment across the learning notes.
tagstech, engineering, mature

4 min read

Software Engineering Practices

Overview

The engineering notes emphasize that good software practice is not one trick or framework. It is a stack of habits: controlling complexity, understanding trade-offs, learning core primitives, and choosing structure that keeps systems easier to change.

Core Areas

Design Quality

Principles such as SOLID show up as recurring tools for reducing coupling and keeping code easier to evolve.

Algorithmic Judgment

Big-O notation appears as a way to reason about scalability and trade-offs in core data and algorithm choices.

Testing and Maintainability

The source notes repeatedly point toward TDD, code review, and structured architecture as ways to keep quality from decaying as systems grow.

Foundational Knowledge

A strong recurring theme is that learning abstractions alone is not enough. Foundational understanding of protocols, systems, and primitives makes later tools easier to use well.

Architecture Awareness

The engineering notes connect day-to-day code practices with bigger structural decisions such as REST API design, hexagonal architecture, and system design trade-offs.

Pull Request Practice

The last five minutes before submitting a PR are cheap and high-leverage, and the order matters.

Step back first. Leave the code, then return and ask one question: is this clean, readable, and easy to maintain? Everything below is a tool; this is the judgment the tools cannot supply.

Then let machines find what machines find. Coverage (CodeCov, Coveralls), automated review (Codacy — which claims 60% of review time saved, CodeFactor), and local gates that fire before the code leaves your machine: git hooks via Husky, Prettier for formatting, and the GitHub CLI.

Stay in one context. Tab-switching between editor, browser and review UI is its own tax, and gh removes most of it:

gh pr create --title "Added new feature" --body "..." --assignee @john
gh pr list --state open          # status without opening the PR page
gh pr review 123 --comment "Thanks, I'll make that change"
gh pr merge 123

Then be humble about what comes back. Ask for feedback rather than defending against it, and treat reviewer expertise as the point of the exercise.

And do not trade quality for the deadline. Delaying a submission to get it right costs less than shipping code that causes problems later.

The AI-native version of this loop — REVIEW.md, severity-ranked passes, corrections fed back into CLAUDE.md — is in AI-Native SDLC, but the human discipline above is what it automates, not what it replaces.

Relationships

  • SOLID — design principles for maintainable object-oriented systems
  • AI-Native SDLC — the same lifecycle with an agent at every stage
  • Constructive Feedback (BIQ) — code review is feedback, and the same specificity rules apply
  • Big-O Notation — algorithmic lens for performance growth
  • Elixir — functional-programming paradigm and immutability as engineering habits
  • Go — simplicity-first language; composition over inheritance, CSP concurrency
  • TypeScript — typed superset of JavaScript; structural typing, type vs interface
  • React — component UI library built on immutability and unidirectional data flow
  • JavaScript Design Patterns — classic and React-era patterns, and which ones Hooks retired
  • Web Rendering and Performance Patterns — CSR/SSR/SSG/ISR/islands plus loading-sequence and bundle discipline
  • UI Design Principles — design craft for developers: constrain the system, let hierarchy do the work
  • Django — Python web framework; ORM QuerySets, views, and middleware
  • Poetry — reproducible Python dependency management
  • Python Async and the asyncio Event Loop — cooperative concurrency: coroutines, tasks, futures, and async vs threads vs processes
  • Observability — understanding running systems from their telemetry
  • Just Use Postgres — resist specialized infrastructure until the load demands it
  • Hexagonal Architecture — example of how design boundaries shape code quality
  • Legacy Systems — living with aging architecture: risk-analyse updates, never half-finish a refactor, document or lose it
  • Problem Finding — the staff-engineer skill of choosing what to build: absorb, accumulate, find the common shape, pressure-test
  • Software Architecture & Distributed Systems — larger system-level design context

References

  • _Best Practice of Software Engineering and Architecture
  • SOLID Training 2021
  • 常用算法Big-O复杂度介绍（时间和空间复杂度）
  • Foundational knowledge is worth a thousand tools

Graph View

Backlinks