// Trigger
trigger AccountTrigger on Account (before insert, before update, after insert, after update, before delete, after delete, after undelete) {
    AccountTriggerHandler.dispatch(Trigger.operationType);
}

// Handler
public class AccountTriggerHandler {
    public static void dispatch(System.TriggerOperation op) {
        switch on op {
            when BEFORE_INSERT  { beforeInsert(Trigger.new); }
            when BEFORE_UPDATE  { beforeUpdate(Trigger.new, Trigger.oldMap); }
            when AFTER_INSERT   { afterInsert(Trigger.new); }
            when AFTER_UPDATE   { afterUpdate(Trigger.new, Trigger.oldMap); }
            when BEFORE_DELETE  { beforeDelete(Trigger.old); }
            when AFTER_DELETE   { afterDelete(Trigger.old); }
            when AFTER_UNDELETE { afterUndelete(Trigger.new); }
        }
    }

    private static void beforeInsert(List<Account> newRecords) {
        // field defaults, validation, stamping
    }

    private static void beforeUpdate(List<Account> newRecords, Map<Id, Account> oldMap) {
        // field changes, conditional logic
    }

    private static void afterInsert(List<Account> newRecords) {
        // related record creation, async calls
    }

    private static void afterUpdate(List<Account> newRecords, Map<Id, Account> oldMap) {
        // cross-object updates, platform events
    }

    private static void beforeDelete(List<Account> oldRecords) {
        // validation, prevent deletion
    }

    private static void afterDelete(List<Account> oldRecords) {
        // cleanup
    }

    private static void afterUndelete(List<Account> newRecords) {
        // restore related data
    }
}

public class TriggerGuard {
    private static Set<String> completedOperations = new Set<String>();

    public static Boolean hasRun(String operationKey) {
        return completedOperations.contains(operationKey);
    }

    public static void setRun(String operationKey) {
        completedOperations.add(operationKey);
    }

    public static void reset(String operationKey) {
        completedOperations.remove(operationKey);
    }
}

public static void afterUpdate(List<Account> newRecords, Map<Id, Account> oldMap) {
    if (TriggerGuard.hasRun('Account_afterUpdate')) return;
    TriggerGuard.setRun('Account_afterUpdate');

    // logic that might cause re-entry
    update relatedContacts;
}

public class AccountTriggerGuard {
    public static Boolean hasRunAfterUpdate = false;
}

public class AccountService {
    @future(callout=true)
    public static void syncToExternal(Set<Id> accountIds) {
        List<Account> accounts = [SELECT Id, Name FROM Account WHERE Id IN :accountIds];
        // HTTP callout logic
    }
}

public class AccountQueueable implements Queueable, Database.AllowsCallouts {
    private List<Id> accountIds;

    public AccountQueueable(List<Id> accountIds) {
        this.accountIds = accountIds;
    }

    public void execute(QueueableContext ctx) {
        List<Account> accounts = [SELECT Id, Name FROM Account WHERE Id IN :accountIds];
        // processing logic
        // chain: System.enqueueJob(new NextQueueable(data));
    }
}
// Enqueue: Id jobId = System.enqueueJob(new AccountQueueable(ids));

public class AccountBatch implements Database.Batchable<sObject>, Database.Stateful {
    public Integer recordsProcessed = 0;

    public Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator('SELECT Id, Name FROM Account WHERE IsActive__c = true');
    }

    public void execute(Database.BatchableContext bc, List<Account> scope) {
        // process scope (default 200 records)
        recordsProcessed += scope.size();
    }

    public void finish(Database.BatchableContext bc) {
        System.debug('Processed ' + recordsProcessed + ' records');
    }
}
// Execute: Id batchId = Database.executeBatch(new AccountBatch(), 200);

public class AccountSchedulable implements Schedulable {
    public void execute(SchedulableContext ctx) {
        Database.executeBatch(new AccountBatch(), 200);
    }
}
// Schedule: System.schedule('Nightly Account Sync', '0 0 2 * * ?', new AccountSchedulable());
// Cron: Seconds Minutes Hours Day Month DayOfWeek OptionalYear

// WITH USER_MODE (preferred, v60.0+)
List<Account> accts = [SELECT Id, Name, Phone FROM Account WITH USER_MODE];

// WITH SECURITY_ENFORCED
List<Account> accts = [SELECT Id, Name, Phone FROM Account WITH SECURITY_ENFORCED];

// stripInaccessible
List<Account> accts = [SELECT Id, Name, Phone, SSN__c FROM Account];
SObjectAccessDecision decision = Security.stripInaccessible(AccessType.READABLE, accts);
List<Account> sanitized = decision.getRecords();
// sanitized records have inaccessible fields removed

// Manual check
if (Schema.sObjectType.Account.fields.Name.getDescribe().isUpdateable()) {
    // safe to update Name
}

String city = account?.BillingAddress?.getCity();   // null if any part is null
String name = contact?.Account?.Name;               // chains safely
Integer len = someString?.length();                  // null if someString is null

// String.isBlank() — true for null, '', and whitespace-only
if (String.isBlank(input)) { /* handle empty */ }

// String.isEmpty() — true for null and '' only (NOT whitespace)
if (String.isEmpty(input)) { /* handle empty */ }

// String.isNotBlank() / String.isNotEmpty() — inverses
if (String.isNotBlank(input)) { /* safe to use */ }

Map<Id, Account> accountMap = new Map<Id, Account>([SELECT Id, Name FROM Account WHERE Id IN :ids]);

// Always check containsKey before get to avoid null
if (accountMap.containsKey(someId)) {
    Account a = accountMap.get(someId);
}

// Or use safe navigation
String name = accountMap.get(someId)?.Name;

// getOrDefault pattern (manual in Apex)
Account a = accountMap.containsKey(someId) ? accountMap.get(someId) : new Account();

// Always initialize — uninitialized List is null, not empty
List<Account> accounts = new List<Account>();

// Null-safe iteration
for (Account a : accounts != null ? accounts : new List<Account>()) {
    // process
}

// Check before access
if (accounts != null && !accounts.isEmpty()) {
    Account first = accounts[0];
}

Set<Id> setA = new Set<Id>{'001...', '001...'};
Set<Id> setB = new Set<Id>{'001...', '001...'};

setA.addAll(setB);      // union
setA.retainAll(setB);   // intersection
setA.removeAll(setB);   // difference
setA.contains(someId);  // membership check

// Deduplicate a list
List<Id> ids = new List<Id>(new Set<Id>(originalList));

// Build lookup map from query
Map<Id, List<Contact>> contactsByAccountId = new Map<Id, List<Contact>>();
for (Contact c : [SELECT Id, AccountId FROM Contact WHERE AccountId IN :accountIds]) {
    if (!contactsByAccountId.containsKey(c.AccountId)) {
        contactsByAccountId.put(c.AccountId, new List<Contact>());
    }
    contactsByAccountId.get(c.AccountId).add(c);
}

// Use map instead of query-per-record
for (Account a : Trigger.new) {
    List<Contact> contacts = contactsByAccountId.get(a.Id);
    if (contacts != null) {
        // process contacts for this account
    }
}