keep-it-simple

# Variables
user_email_address = "user@example.com"
total_price_with_tax = calculate_price(items)
is_authenticated = check_user_auth(user)

# Functions
def calculate_total_price(items):
    """Calculate the total price including tax."""
    pass

def send_welcome_email(user):
    """Send welcome email to newly registered user."""
    pass

# Classes
class UserRepository:
    """Handles database operations for users."""
    pass

# Too short/cryptic
ue = "user@example.com"
tpwt = calc(items)
auth = chk(u)

# Too generic
data = fetch_data()
process(info)
result = do_something()

# Misleading
def get_user(user_id):
    # Also sends email and updates cache!
    pass

# Do ONE thing
def calculate_tax(subtotal, tax_rate):
    return subtotal * tax_rate

# Use early returns
def process_order(order):
    if not order:
        return None
    if not order.is_valid():
        return None
    if order.total <= 0:
        return None

    return complete_order(order)

# Clear parameters
def create_user(email, username, password):
    # 3 clear parameters beats 1 config dict
    pass

# Does too many things
def process_user_data(data, mode, options, callback=None):
    # 100 lines of mixed concerns
    pass

# Too many parameters
def create_report(start, end, user, format, filters, sort,
                  group, limit, offset, include_meta):
    pass

# Deep nesting
def validate(data):
    if data:
        if data.get('user'):
            if data['user'].get('email'):
                if '@' in data['user']['email']:
                    # 4 levels deep!
                    pass

// Local state when possible
const [count, setCount] = useState(0);

// Lift state only when needed
const [user, setUser] = useState(null);

// Context for truly global state
const { theme } = useTheme();

// Don't do this unless you really need it
const dispatch = useDispatch();
const count = useSelector(selectCount);
const loading = useSelector(selectCountLoading);
const error = useSelector(selectCountError);
dispatch(incrementCountStart());

# Extract to named variables
is_weekend = day in ['Saturday', 'Sunday']
is_holiday = day in holidays
is_day_off = is_weekend or is_holiday

if is_day_off:
    send_greeting()

# Use guard clauses
def process_payment(amount, user):
    if amount <= 0:
        return "Invalid amount"
    if not user.is_verified:
        return "User not verified"

    return complete_payment(amount, user)

# Too much in one line
if (user.age >= 18 and user.verified and not user.banned and
    user.credits > 0 and user.last_login < threshold):
    process()

# Too many branches
if mode == 'A':
    # ...
elif mode == 'B':
    # ...
elif mode == 'C':
    # ...
# 10 more elif statements...

class Task:
    def __init__(self, title, due_date):
        self.title = title
        self.due_date = due_date

    def is_overdue(self):
        return datetime.now() > self.due_date

class AbstractTaskFactoryBuilder:
    def create_builder(self):
        return TaskBuilder(
            TaskValidator(),
            TaskFormatter(),
            TaskSerializer()
        )

def fetch_user_data(user_id):
    response = requests.get(f"{API_URL}/users/{user_id}")
    response.raise_for_status()
    return response.json()

class APIClientFactory:
    def create_client(self, config):
        return APIClient(
            RequestBuilder(config),
            ResponseParser(config),
            ErrorHandler(config),
            CacheManager(config)
        )

def get_active_users(users):
    return [user for user in users if user.is_active]

class UserFilterStrategy:
    def apply_filter(self, users, predicate):
        return list(filter(predicate, users))

filter_strategy = UserFilterStrategy()
active_users = filter_strategy.apply_filter(
    users,
    lambda u: u.is_active
)