Code-tips

Methods should either be commands that perform actions or queries that return data to the caller, but not both.

Clients should not be forced to depend upon interfaces that they do not use. Large interfaces should be broken up into smaller interfaces.

Choose a capitalization style for variables, functions, and other identifiers, and adhere to it throughout your codebase. Consistency improves code readability.

Prefer duplication over the wrong abstraction. Avoid rushing into creating abstractions without a clear understanding of the problem domain.

Code duplication is often frowned upon. However, it can be more beneficial to have duplicated code rather than introducing premature abstraction.

Avoid duplicating the same information in multiple places. The DRY principle encourages developers to eliminate code duplication by abstracting functionality.

Only implement what's necessary. Avoid premature optimization. Keep code simple and focused on current requirements.

Improve code reliability by avoiding side effects. Minimize hidden consequences, enhance predictability, and simplify testing.

Thrown errors are a good thing and you can do something about them. The rule is “Don't ignore caught errors”

Thrown errors are a good thing and you can do something about them. The rule is “Don't ignore caught errors”

The rule is really simple. The only thing you have to do is to choose a single concept to test in every unit test you write.

Learn about the KISS principle and its impact on software development. Prioritize simplicity, improve maintainability, and enhance code readability.

Ensure clarity and maintainability in your codebase by using consistent vocabulary for the same concept. Stick to one word per concept.

Learn how to write clear and concise code by avoiding unnecessary repetition of context in variable names. Enhance code readability and maintainability.

Discover how to encapsulate conditionals for clearer code. Extract expressions into functions with meaningful names to improve readability and simplify logic.

Discover the benefits of removing dead code - improved maintainability, reduced risk of bugs, enhanced readability, and better performance.

Negatives are harder to understand. Conditional functions should be expressed as positives every time.

Discover the Liskov Substitution Principle (LSP) and its role in building reliable software. Guarantee seamless substitution of parent and child classes.

Learn about the Open-Closed Principle (OCP) and its benefits. Extend functionality without modifying code, ensuring maintainability and reusability.

Each class should have a single responsibility. That means that there should be only one reason to change it. This is one of the SOLID principles.

Discover how the Dependency Inversion Principle improves code maintainability and modularity by relying on abstractions and inverting control of dependencies.

Trying to optimize your code is a waste of time in some cases. Modern browsers do a lot of optimizations at runtime.

Using getters and setters is better than accessing the object property directly. Accessing properties directly breaks encapsulation.

Simplify your code and improve testability by minimizing function arguments. Discover how fewer arguments enhance readability and maintainability.

Follow best practices and adhere to the single responsibility principle by not using flags as function parameters. Improve code comprehension and modularity.

Say what the function does with its name. The name should tell you what it expects as inputs as well.

Choosing good names takes time but it saves even more time. Names should give you useful information.

Learn the importance of using pronounceable names in your code. Discover how it improves communication and enhances code readability and maintainability.

Improve code clarity and searchability by replacing magic numbers with constants. Make your code more expressive and self-explanatory.

Master the technique of avoiding mental mapping in your code. Enhance readability and eliminate confusion with explicit variable naming.

Break the calculations up into intermediate values that are held in variables with meaningful names. The names give meaning and clarity to the code.

Discover the principle of writing functions that do one thing. Improve code modularity, reusability, and organization for a cleaner codebase.

Do you want to make your code super flexible and easy to change? Composition might be the way to go! In this post, we'll learn about the difference between composition and inheritance and figure out which one is best for different situations.

ES6 is better than ES5 for readable class inheritance, construction and methods.