An automated Twitter bot that posts tech-related content 5 times daily using GitHub Actions. https://github.com/jvcByte/twitter_bot

JVC — Sat, 04 Apr 2026 23:58:57 +0000

GitHub - jvcByte/twitter_bot: An automated Twitter bot that posts tech-related content 5 times daily using GitHub Actions. · GitHub

An automated Twitter bot that posts tech-related content 5 times daily using GitHub Actions. - jvcByte/twitter_bot

github.com

16 Best Practices for Writing Super Readable Code

JVC — Sun, 22 Feb 2026 15:52:14 +0000

1. Use Clear, Descriptive Names
Pick variable, function, class, and module names that clearly describe their purpose. Good naming dramatically reduces the need for extra explanation.

Bad naming destroys readability faster than any other mistake:

def calc(x, y):
    return x * y * 0.08

Good naming eliminates 50% of unnecessary comments:

def calculate_sales_tax(price, quantity):
    return price * quantity * TAX_RATE

2. Keep Functions and Methods Small
Each function should do one thing and do it well. Smaller, focused functions are easier to test, understand, and reuse.

3. Avoid Deep Nesting
Heavy nesting (many layers of if, for, etc.) makes code harder to follow. Use early returns, helper functions, or guard clauses to flatten logic.

Hard to Read:

def get_discount(user):
    if user:
        if user.is_active:
            if user.orders > 10:
                return 0.2
    return 0

Use guard clauses:

def get_discount(user):
    if not user or not user.is_active:
        return 0
    if user.orders > 10:
        return 0.2
    return 0

4. Avoid Magic Numbers and Strings
Use named constants instead of unexplained literal values. This shows intent and reduces errors.

Magic number:

if temperature > 37.5:
    alert()

Named constant:

FEVER_THRESHOLD_CELSIUS = 37.5

if temperature > FEVER_THRESHOLD_CELSIUS:
    alert()

5. Apply DRY (Don’t Repeat Yourself)
Duplicate code makes updates harder and increases bugs. Abstract repeated logic into reusable functions, modules, or classes.

Repeated logic:

total1 = price1 * 0.9
total2 = price2 * 0.9

Extract function:

def apply_discount(price, discount_rate):
    discount_amount = price * discount_rate
    return price - discount_amount

6. Follow Single Responsibility Principle (SRP)
Design your code so each class or function has one responsibility. This enhances readability and architecture quality.
When a class or function does multiple things:

Changes become risky
Debugging becomes harder
Understanding takes longer

Doing too much:

class User:
    def save(self):
        pass
    def send_email(self):
        pass

Separate responsibilities:

class UserRepository:
    def save(self, user):
        pass

class EmailService:
    def send(self, user):
        pass

7. Refactor Regularly
Clean code isn’t a one-time job. Regular refactoring improves clarity, simplifies logic, and removes technical debt.

8. Use Consistent Formatting
Consistent indentation, spacing, and bracket placement make your code visually predictable. Follow a style guide:

9. Follow Consistent Naming Conventions
Stick with the naming style rules of your language or project (e.g., camelCase, snake_case, PascalCase). This fosters predictability and reduces cognitive load.

Inconsistent:

userName = "Alice"
user_age = 25
UserEmail = "a@mail.com"

Consistent (snake_case):

user_name = "Alice"
user_age = 25
user_email = "a@mail.com"

10. Comment Judiciously
Comments should explain why something is done, not what it does. Avoid obvious or redundant comments.

Redundant:

# Increment i by 1
i += 1

Useful:

# Retry once due to known third-party API timeout issue
retry_count += 1

11. Leverage Linters & Formatters
Formatters auto-enforce formatting rules so your code looks uniform across the whole team.

12. Prefer Simplicity Over Cleverness
Readable code favors straightforward solutions. Avoid clever one-liners or premature optimization that sacrifices clarity for minor performance gains.

Clever one-liner:

result = list(map(lambda x: x*2, filter(lambda x: x>5, nums)))

Clear:

result = []
for number in nums:
    if number > 5:
        result.append(number * 2)

13. Modularize Your Code
Break your codebase into logical, well-defined modules or components so related behaviors stay together and unrelated parts stay separate.

Everything in one file:

app.py

Organized:

app/
  ├── models.py
  ├── services.py
  ├── routes.py

14. Understand and Apply Design Patterns Appropriately
Design patterns provide proven structures for common problems, making code more understandable to experienced developers without reinventing logic.

Random object creation everywhere:

db = Database()

Singleton pattern:

class Database:
    _instance = None

    @staticmethod
    def get_instance():
        if Database._instance is None:
            Database._instance = Database()
        return Database._instance

15. Write Tests
Unit and integration tests act as living documentation and guarantee that your code works as intended over time.

Example:

def test_apply_discount():
    assert apply_discount(100, 0.1) == 90

16. Use version control properly
Use version control well by creating dedicated branches for features, merging early and often to avoid large, hard-to-review changes, and using pull requests or merge requests to review code readability before it reaches the main branch. At the same time, write meaningful commit messages that clearly explain why a change was made (not just what changed), since commits form a readable project history that is invaluable for debugging, onboarding new developers, and understanding decisions months or years later.

Bad commit:

fix stuff

Good commit:

Fix incorrect tax calculation when quantity > 10

Recently shipped a new, minimalist ENS (Ethereum Name Service) application.

JVC — Sun, 21 Sep 2025 19:21:01 +0000

This project began as a task assigned to me. My curiosity led me to explore the possibilities, and I broke a lot of things in the process, to the point of suspecting my PC! Ultimately, I learned the strengths and weaknesses of using raw JSON-RPC, Wagmi, and Viem. While Wagmi is great for simple wallet connections and reading from the blockchain, its extensive feature set can make your code feel bulky. JSON-RPC can be a headache, and I wouldn't recommend it for complex applications.

To streamline my code, I created a custom hook that uses Wagmi for wallet and public actions, including event monitoring and reading from contracts (with the help of TanStack Query). For contract interactions that involve state changes, I used Viem, as it is a more lightweight and flexible alternative for that specific task.

What I like most about this project:
Seamless wallet connectivity with automatic network switching to where the contract was deployed.
Real-time blockchain event monitoring (registrations, transfers, updates).
A clean, responsive UI.
State management with TanStack Query for an optimal user experience.

The beauty of Web3 development is in building transparent, user-centric applications that give users control over their digital identity.

Check out the code and the live demo!
Demo: nameservice.
Code: ens.

I'm always excited to discuss Web3 architecture and development patterns.

DEV Community: JVC

An automated Twitter bot that posts tech-related content 5 times daily using GitHub Actions. https://github.com/jvcByte/twitter_bot

GitHub - jvcByte/twitter_bot: An automated Twitter bot that posts tech-related content 5 times daily using GitHub Actions. · GitHub

16 Best Practices for Writing Super Readable Code

Recently shipped a new, minimalist ENS (Ethereum Name Service) application.