Software Development Best Practices

Naming Conventions ```javascript // BAD: Cryptic names const d = new Date(); const u = await getU(id); function proc(x, y) { return x * y * 0.15; }

// GOOD: Intention-revealing names const orderCreatedAt = new Date(); const user = await getUserById(userId); function calculateTaxAmount(subtotal, taxRate) { return subtotal * taxRate; }

// GOOD: Boolean names should read as predicates let isLoggedIn = false; let hasPermission = true; let shouldRedirect = true;

// BAD: Ambiguous boolean let flag = true; let status = false;

// GOOD: Function names as verb phrases function sendConfirmationEmail(order) { } function validateCreditCard(cardNumber) { } function getActiveUsersCount() { } function parseQueryParams(url) { } ```

Function Design ```javascript // Functions should do ONE thing // BAD: Does multiple things async function processOrder(orderId) { const order = await db.orders.findById(orderId); const user = await db.users.findById(order.userId); const tax = order.subtotal * 0.08; const total = order.subtotal + tax + order.shipping; await stripe.charges.create({ amount: total, currency: "usd" }); await sendEmail(user.email, "Order confirmed", buildConfirmationEmail(order)); await db.orders.update(orderId, { status: "confirmed", total }); await db.inventory.decrementBatch(order.items); console.log("Order processed:", orderId); }

// GOOD: Each function does one thing, composed together async function processOrder(orderId) { const order = await fetchOrderWithUser(orderId); const total = calculateOrderTotal(order); await chargeCustomer(order, total); await fulfillOrder(order); await notifyCustomer(order); }

// Each helper function: single responsibility, testable in isolation

// Function length: aim for < 20 lines // Arguments: max 3 use object parameter if more needed function createUser({ name, email, role = "user", plan = "free" }) { } ```

SOLID in Practice ```javascript // S Single Responsibility // BAD: User class handles auth, email, AND data class User { login() { /* auth logic */ } sendWelcomeEmail() { /* email logic */ } saveToDatabase() { /* db logic */ } }

// GOOD: Separate concerns class AuthService { login(email, password) { } } class EmailService { sendWelcomeEmail(user) { } } class UserRepository { save(user) { } }

// O Open/Closed (open for extension, closed for modification) // BAD: Modify class to add discount types class PriceCalculator { calculate(price, discountType) { if (discountType === "percentage") return price * 0.9; if (discountType === "fixed") return price - 10; // must modify class to add new types } }

// GOOD: New discount types extend without modifying class PercentageDiscount { apply(price) { return price * 0.9; } } class FixedDiscount { apply(price) { return price - 10; } } class PriceCalculator { calculate(price, discount) { return discount.apply(price); // any discount object works } }

// L Liskov Substitution // Every subclass must be substitutable for parent // I Interface Segregation // Prefer small, focused interfaces over large general ones // D Dependency Inversion // Depend on abstractions, not concretions (inject dependencies) ```

Common Design Patterns ``javascript // Factory Pattern create objects without specifying exact class class NotificationFactory { static create(type) { const channels = { email: EmailNotification, sms: SMSNotification, push: PushNotification, }; const Channel = channels[type]; if (!Channel) throw new Error(Unknown channel: ${type}`); return new Channel(); } }

// Observer Pattern publish/subscribe class EventEmitter { #listeners = new Map(); on(event, listener) { if (!this.#listeners.has(event)) this.#listeners.set(event, []); this.#listeners.get(event).push(listener); return () => this.off(event, listener); // return unsubscribe fn } emit(event, data) { this.#listeners.get(event)?.forEach(fn => fn(data)); } }

// Repository Pattern abstract data access class UserRepository { async findById(id) { return db.users.findOne({ id }); } async findByEmail(email) { return db.users.findOne({ email }); } async save(user) { return db.users.upsert(user); } async delete(id) { return db.users.delete({ id }); } } // Service layer calls UserRepository, not DB directly // Easy to swap storage backend, easy to mock in tests ```