Code Quality

// ❌ Cryptic namesconst d = new Date();const u = getU();const arr = data.filter(x => x.s === 'a');
// ✅ Descriptive namesconst currentDate = new Date();const currentUser = getCurrentUser();const activeUsers = users.filter(user => user.status === 'active');
// ❌ Hungarian notation (outdated)const strName = 'John';const arrItems = [];const bIsActive = true;
// ✅ Let the type system handle typesconst name = 'John';const items: Item[] = [];const isActive = true;

// ❌ Does too muchfunction processUserData(userId: string) {  const user = db.findUser(userId);  const orders = db.findOrders(userId);  const total = orders.reduce((sum, o) => sum + o.amount, 0);  sendEmail(user.email, `Your total: ${total}`);  updateAnalytics(userId, total);  return { user, orders, total };}
// ✅ Single responsibilityfunction getUser(userId: string): User {  return db.findUser(userId);}
function getUserOrders(userId: string): Order[] {  return db.findOrders(userId);}
function calculateTotal(orders: Order[]): number {  return orders.reduce((sum, o) => sum + o.amount, 0);}
function sendOrderSummary(user: User, total: number): void {  sendEmail(user.email, `Your total: ${total}`);}
// ❌ Too many parametersfunction createUser(name, email, age, role, department, manager, startDate) {}
// ✅ Use object parameterinterface CreateUserParams {  name: string;  email: string;  age?: number;  role: Role;  department: string;  managerId?: string;  startDate: Date;}
function createUser(params: CreateUserParams): User {}

// ❌ Redundant comment// Increment counter by 1counter++;
// ❌ Outdated comment (code changed, comment didn't)// Returns the user's full namefunction getUserEmail(user: User) {  return user.email;}
// ✅ Explains WHY, not WHAT// Use binary search because the list is sorted and can have 100k+ itemsconst index = binarySearch(sortedItems, target);
// ✅ Warns about non-obvious behavior// IMPORTANT: This function mutates the input array for performance reasonsfunction quickSort(arr: number[]): number[] {  // ...}
// ✅ TODO with context// TODO(john): Remove after migration completes - tracking in JIRA-1234const legacyAdapter = new LegacyAdapter();

// ❌ Multiple responsibilitiesclass UserManager {  createUser(data: UserData) { /* DB logic */ }  validateEmail(email: string) { /* Validation logic */ }  sendWelcomeEmail(user: User) { /* Email logic */ }  generateReport(users: User[]) { /* Report logic */ }}
// ✅ Single responsibility eachclass UserRepository {  create(data: UserData): User { /* DB logic */ }  findById(id: string): User | null { /* DB logic */ }}
class UserValidator {  validateEmail(email: string): boolean { /* Validation */ }  validatePassword(password: string): ValidationResult { /* Validation */ }}
class EmailService {  sendWelcomeEmail(user: User): void { /* Email logic */ }}
class UserReportGenerator {  generate(users: User[]): Report { /* Report logic */ }}

// ❌ Must modify to add new payment methodsclass PaymentProcessor {  process(payment: Payment) {    if (payment.type === 'credit') {      // Credit card logic    } else if (payment.type === 'paypal') {      // PayPal logic    } else if (payment.type === 'crypto') {      // Crypto logic - had to modify existing code!    }  }}
// ✅ Open for extension, closed for modificationinterface PaymentMethod {  process(amount: number): Promise<PaymentResult>;}
class CreditCardPayment implements PaymentMethod {  async process(amount: number): Promise<PaymentResult> { /* ... */ }}
class PayPalPayment implements PaymentMethod {  async process(amount: number): Promise<PaymentResult> { /* ... */ }}
// New payment method - no modification to existing codeclass CryptoPayment implements PaymentMethod {  async process(amount: number): Promise<PaymentResult> { /* ... */ }}
class PaymentProcessor {  constructor(private method: PaymentMethod) {}
  async process(amount: number): Promise<PaymentResult> {    return this.method.process(amount);  }}

// ❌ Violates LSP - Square breaks Rectangle contractclass Rectangle {  constructor(public width: number, public height: number) {}
  setWidth(w: number) { this.width = w; }  setHeight(h: number) { this.height = h; }  getArea() { return this.width * this.height; }}
class Square extends Rectangle {  setWidth(w: number) {    this.width = w;    this.height = w; // Unexpected side effect!  }  setHeight(h: number) {    this.width = h;    this.height = h; // Unexpected side effect!  }}
// ✅ Proper abstractioninterface Shape {  getArea(): number;}
class Rectangle implements Shape {  constructor(private width: number, private height: number) {}  getArea() { return this.width * this.height; }}
class Square implements Shape {  constructor(private side: number) {}  getArea() { return this.side * this.side; }}

// ❌ Fat interfaceinterface Worker {  work(): void;  eat(): void;  sleep(): void;  attendMeeting(): void;  writeReport(): void;}
// Robot can't eat or sleep!class Robot implements Worker {  work() { /* ... */ }  eat() { throw new Error('Robots do not eat'); }  // Forced to implement  sleep() { throw new Error('Robots do not sleep'); }  // ...}
// ✅ Segregated interfacesinterface Workable {  work(): void;}
interface Eatable {  eat(): void;}
interface Sleepable {  sleep(): void;}
class Human implements Workable, Eatable, Sleepable {  work() { /* ... */ }  eat() { /* ... */ }  sleep() { /* ... */ }}
class Robot implements Workable {  work() { /* ... */ }}

// ❌ High-level depends on low-levelclass OrderService {  private db = new MySQLDatabase();  // Concrete dependency  private mailer = new SendGridMailer();  // Concrete dependency
  createOrder(data: OrderData) {    const order = this.db.insert('orders', data);    this.mailer.send(data.email, 'Order confirmed');    return order;  }}
// ✅ Depend on abstractionsinterface Database {  insert(table: string, data: unknown): unknown;  find(table: string, query: unknown): unknown[];}
interface Mailer {  send(to: string, message: string): void;}
class OrderService {  constructor(    private db: Database,    private mailer: Mailer  ) {}
  createOrder(data: OrderData) {    const order = this.db.insert('orders', data);    this.mailer.send(data.email, 'Order confirmed');    return order;  }}
// Now we can inject any implementationconst service = new OrderService(  new PostgresDatabase(),  new SESMailer());

// High complexity (10+) - hard to test and maintainfunction processOrder(order: Order): Result {  if (order.status === 'pending') {           // +1    if (order.paymentMethod === 'card') {     // +1      if (order.amount > 1000) {              // +1        // ...      } else if (order.amount > 100) {        // +1        // ...      } else {        // ...      }    } else if (order.paymentMethod === 'cash') {  // +1      // ...    }  } else if (order.status === 'processing') {  // +1    // ...  }  // ... more branches}
// Lower complexity - extract conditionsfunction processOrder(order: Order): Result {  const processor = getProcessor(order.paymentMethod);  const tier = getPricingTier(order.amount);  return processor.process(order, tier);}