The hottest Refactoring Substack posts right now

And their main takeaways
Category
Top Technology Topics

Tidying: Canonical Order

Software Design: Tidy First? • 132 implied HN points • 28 Nov 25
🕹 Technology Refactoring
  1. The piece looks at 'canonical order' in tidying code — how to pick a consistent order for things like variable declarations.
  2. A tiny example (int x, y vs int y, x) shows that order can change and asks whether a basic principle should decide which order is correct.
  3. The detailed discussion is behind a paid subscriber paywall, and the author also offers to give talks to teams or organizations.

Additional Testing After Refactoring

Software Design: Tidy First? • 950 implied HN points • 20 Jan 25
🕹 Technology Refactoring
  1. It's important to write more tests after refactoring. This helps improve accuracy and confidence in your code.
  2. When you break down a big piece of code into smaller parts, consider writing smaller tests for those parts, especially if you plan to reuse them.
  3. You might face a dilemma on whether to keep redundant tests after refactoring. It's good to regularly review tests to make sure you have the best approach for checking your code.

Refactoring: Narrow ↔ Widen Parameter

Software Design: Tidy First? • 530 implied HN points • 25 Nov 24
🕹 Technology Refactoring
  1. Narrowing and widening parameters are important techniques in refactoring code. They help make the code more flexible and easier to understand.
  2. Refactoring can initially seem tricky, but it can also be enjoyable and rewarding. It's a good practice to keep improving your code.
  3. Getting feedback on your refactoring efforts is valuable. It helps you see what works and what can be improved.

Do You Want to Remove "If" Statements From Your Java Code?

Weekend Developer • 19 implied HN points • 11 May 24
🕹 Technology Refactoring
  1. To reduce reliance on 'if' statements in Java code, use guard statements at the beginning of methods or blocks to quickly exit when conditions aren't met.
  2. Consider using ternary operators as a concise way to replace 'if-else' statements within methods, but be cautious of overusing them for readability.
  3. Separate logic into reusable policy rules, encapsulating business rules into classes or methods, to promote code organization and maintainability.
Get a weekly roundup of the best Substack posts, by hacker news affinity:

"Technical Debt" is a bad metaphor

Cybersect • 39 implied HN points • 31 May 23
🕹 Technology Refactoring
  1. Technical debt is misused and misunderstood in software engineering, often seen as a moral crusade against bad code.
  2. Refactoring is essential for addressing technical debt, focusing on making code more readable and maintainable.
  3. The concept of technical debt is not about avoiding problems but understanding the ongoing costs of decisions in software development.

How to stay motivated while learning Java?

Weekend Developer • 19 implied HN points • 06 Oct 23
🕹 Technology Refactoring
  1. When learning Java, start by writing code as if you're in a procedural language to ease the transition
  2. Writing unit test cases is important to become a seasoned Java programmer; it helps validate your code
  3. Refactor your code by breaking logic into simpler methods, identifying and grouping methods/variables into classes, and reviewing your code for improvements

Building Exceptional Code: 6 Not So Simple Steps To Make Code Simple

Weekend Developer • 19 implied HN points • 08 Jul 23
🕹 Technology Refactoring
  1. Understand the principles like Single Responsibility, Don't Repeat Yourself, Dependency Inversion, and Separation of Concerns to write modular and reusable code.
  2. Modularize your code by breaking it into smaller, focused modules, think of them as Lego blocks. Favor composition over inheritance for flexible and loosely coupled designs.
  3. Write testable code by isolating dependencies, mocking external dependencies, keeping methods small, and following Test-Driven Development. Apply design patterns judiciously and continuously refactor to improve code quality.

Refactoring BabyAGI - Code Quality and LLMs

Laszlo’s Newsletter • 27 implied HN points • 04 May 23
🕹 Technology Refactoring
  1. When refactoring code, it's important to move code into service classes for better organization and readability.
  2. Utilize constants and parameters closer to their use for easier handling of configurations and serialization/deserialization.
  3. Consider refactoring to address code smells like 'Feature Envy' and 'Primitive Obsession' to improve code maintainability and readability.

Refactoring BabyAGI - Code Quality and LLMs

Laszlo’s Newsletter • 5 implied HN points • 08 May 23
🕹 Technology Refactoring
  1. The main change in refactoring the Task class is simplifying the code to improve clarity.
  2. Changes in database structures were made to accommodate the new Task class, showing the importance of maintaining consistency.
  3. Goals of implementing Clean Architecture and introducing the Task class were successfully achieved through refactoring, improving code maintainability and expressiveness.

Simplify Your Control Flow Code, Part 2

🔮 Crafting Tech Teams • 0 implied HN points • 05 Jul 23
🕹 Technology Refactoring
  1. Part 2 of control-flow refactoring addresses nullable return values and the effects of going too far with simplification.
  2. Refactoring complex branching logic can make code more readable and maintainable.
  3. Consider balancing between simplifying control flow and maintaining clarity in code to avoid making it overly complex.

Writing unit tests for SQL queries

Reflective Software Engineering • 0 implied HN points • 12 Jan 24
🕹 Technology Refactoring
  1. Having unit tests for SQL queries can help catch bugs introduced during code refactorings or changes.
  2. When writing unit tests for SQL queries, focus on testing the specific parts responsible for building the query rather than the entire method.
  3. Refactoring code for testability can involve moving pure functions outside of the class for easier testing and simplifying methods to focus on specific tasks.

The Hidden Secrets of Design Patterns: What No One Talks About

Weekend Developer • 0 implied HN points • 22 Jun 24
🕹 Technology Refactoring
  1. Understanding design patterns helps in building robust and maintainable software by providing standard solutions to common problems.
  2. Challenges of design patterns include a learning curve, potential overuse, and selecting the right pattern for the context.
  3. To effectively use design patterns, invest time in understanding them, assess if they are necessary, regularly review and refactor code, seek feedback from peers, and document pattern choices.

Test-driven data engineering

Reflective Software Engineering • 0 implied HN points • 30 Dec 23
🕹 Technology Refactoring
  1. Test-driven development (TDD) is a valuable tool for ensuring software quality and driving great software design.
  2. Testing data integrations and clients, especially in complex data platforms, can be challenging due to less control over underlying databases. Strategies like mocking HTTP interactions can help in testing.
  3. Separating concerns and creating small, testable units of code can enhance confidence in the system, reduce fear of regression, and improve overall software quality.

From Messy to Marvelous: Mastering the Craft of Clean Code

Weekend Developer • 0 implied HN points • 18 Sep 23
🕹 Technology Refactoring
  1. Clean code is essential for software maintainability, collaboration, debugging, scalability, and reducing technical debt.
  2. Principles of clean code include using meaningful names, avoiding code duplication, ensuring single responsibility, keeping functions small, maintaining consistent coding styles, focusing on testability, and continuous refactoring.
  3. Practical tips for writing clean code involve using descriptive names, breaking long functions into smaller ones, avoiding deep nesting, keeping comments updated, and removing dead code.

Don’t Use Boolean Arguments, Use Enums

ChughGPT, my personal LLM • 0 implied HN points • 20 Apr 20
🕹 Technology Refactoring
  1. Avoid using boolean arguments and opt for enums instead to manage states in your code.
  2. Booleans can lead to code complexity, readability issues, and hidden dependencies when handling multiple states.
  3. Enums offer clarity, scalability, and type safety, making them a preferred choice over booleans for managing finite states in code.

Harden Product Quality by Refactoring Code Smells

🔮 Crafting Tech Teams • 0 implied HN points • 25 Jul 23
🕹 Technology Refactoring
  1. Understanding code smells can help improve product quality by enabling timely refactoring to address potential issues.
  2. Refactoring code smells involves following established methodologies that lead to better object-oriented design and the application of design patterns.
  3. Sandi Metz emphasizes the importance of continuous refactoring to maintain code quality, highlighting the value of small methods and classes.