Software-engineering — Topic Index

Below is an index of articles grouped by topic. Click a heading to jump to the section.

Programming

• Code Quality Metrics: Measuring and Improving Code
  • Comprehensive guide to code quality metrics. Learn about complexity, maintainability, linting, static analysis, and building quality gates.
• Debugging Techniques: Find and Fix Bugs Effectively
  • Comprehensive guide to debugging techniques. Learn about browser devtools, logging, breakpoints, profiling, and systematic approaches to finding and fixing bugs.
• Documentation Best Practices: Comprehensive Guide
  • Comprehensive guide to technical documentation. Learn about ADRs, READMEs, API docs, code comments, and building maintainable documentation systems.
• Unit Testing Best Practices: Comprehensive Guide
  • Comprehensive guide to unit testing best practices. Learn about test organization, naming conventions, mocking strategies, code coverage, and building maintainable test suites.

Software Engineering

• Agentic AI: Building Autonomous AI Systems That Act and Reason
  • Master agentic AI architecture including planning, tool use, reflection, and building production AI agents that can reason, plan, and execute complex tasks.
• AI Code Review Automation: Complete Guide for 2026
  • Transform your code review process with AI automation. Learn how to implement AI-powered code review tools, integrate with GitHub, GitLab, and build custom code review systems.
• AI Engineering: Building Production-Ready AI Systems
  • Master AI engineering practices including MLOps, model deployment, monitoring, and building reliable AI-powered applications at scale.
• API Caching Patterns: Redis, CDN, and HTTP Caching Strategies
  • Master API caching with Redis, CDN, and HTTP caching. Learn cache-aside, write-through, and invalidation patterns for high-performance applications.
• API Design Guidelines: Building Robust and Scalable Interfaces
  • Comprehensive guide to API design principles, REST constraints, resource modeling, and best practices for building maintainable web APIs in 2026.
• API Gateways: Kong, Envoy, and Modern API Management
  • Comprehensive guide to API gateways, Kong, Envoy, and building scalable API management infrastructure
• API Gateways: Kong, Envoy, and Modern API Management in 2026
  • Learn how API gateways provide routing, authentication, rate limiting, and observability for microservices architectures.
• API Gateways: Routing, Authentication, and Rate Limiting
  • A comprehensive guide to API gateways including request routing, authentication, rate limiting, request transformation, and Kong/Traefik configuration.
• API Rate Limiting and Throttling: Complete Guide to Protecting Your Services
  • Master rate limiting strategies including token bucket, leaky bucket, sliding window, and building effective throttling systems for APIs at scale.
• API Rate Limiting: Token Bucket, Leaky Bucket, and Sliding Window Algorithms
  • Master API rate limiting with token bucket, leaky bucket, and sliding window algorithms. Learn implementation patterns for protecting your APIs from abuse.
• API Security Patterns: Authentication, Authorization, and Protection Strategies
  • A comprehensive guide to API security patterns including OAuth 2.0, JWT, API keys, rate limiting, and protection against common vulnerabilities.
• API Versioning Strategies: Evolution Without Breaking Changes
  • Master API versioning to evolve your APIs without disrupting clients. Learn URI path versioning, header-based versioning, query parameter versioning, and best practices for API evolution.
• API Versioning Strategies: Managing Breaking Changes
  • Master API versioning with strategies for URL paths, headers, query parameters, and media types. Learn deprecation patterns, migration strategies, and building APIs that evolve gracefully.
• Async Programming: Complete Guide to Concurrency and Parallelism
  • Master asynchronous programming with Python asyncio and JavaScript async/await. Build high-performance concurrent applications with proper patterns.
• Authentication and Authorization: Security Patterns
  • Learn authentication methods, authorization patterns, OAuth 2.0, JWT, RBAC, and building secure identity systems.
• Building APIs with GraphQL: Advanced Patterns and Complete Optimization Guide
  • Master advanced GraphQL patterns including data loaders, subscriptions, federation, caching, and performance optimization for production systems.
• Building CLI Tools: Command-Line Applications with Modern Tools
  • Master building CLI applications with Python and Go. Learn argument parsing, interactive prompts, and creating excellent user experiences.
• Building Real-Time Applications: WebSockets and Server-Sent Events
  • Master real-time communication patterns including WebSockets, Server-Sent Events, and building responsive live applications.
• Building Real-Time Dashboards: WebSocket, Server-Sent Events, and Polling
  • Master building real-time dashboards with WebSocket, Server-Sent Events, and polling. Learn patterns for live data updates, dashboard architecture, and production considerations.
• Building Type-Safe APIs: TypeScript, Python, and Runtime Validation
  • Master type-safe API development including TypeScript, Python type hints, runtime validation, and building robust applications with compile-time and runtime type safety.
• Caching Strategies: Complete Guide to In-Memory, Redis, and CDN Caching
  • Master caching strategies including in-memory caching, Redis patterns, and CDN integration for building high-performance, scalable applications.
• Caching Strategies: Redis, CDN, and HTTP Caching for High-Performance Applications
  • A comprehensive guide to caching strategies including Redis caching, CDN caching, HTTP caching headers, and cache invalidation patterns for building high-performance applications.
• Chaos Engineering: Building Resilient Distributed Systems
  • A comprehensive guide to chaos engineering including principles, LitmusChaos experiments, fault injection, and building resilient systems.
• Chaos Engineering: Building Resilient Systems Through Controlled Experiments
  • Learn how chaos engineering principles help teams discover weaknesses in production systems before they cause outages.
• CI/CD Pipelines: Building Automated Delivery Pipelines
  • A comprehensive guide to CI/CD pipeline design including GitHub Actions, GitLab CI, testing strategies, deployment patterns, and quality gates.
• Circuit Breaker Pattern: Building Resilient Microservices
  • Learn the Circuit Breaker pattern to prevent cascading failures in distributed systems. Implement resilience with timeouts, retries, and fallback strategies.
• Circuit Breaker Pattern: Preventing Cascade Failures in Distributed Systems
  • Learn how to implement the Circuit Breaker pattern to prevent cascade failures and build resilient microservices. Covers states, implementations, and best practices.
• Clean Code Principles: Writing Maintainable Software
  • Master clean code principles including SOLID, DRY, KISS, YAGNI. Learn refactoring techniques, meaningful naming, and how to write code that your future self will thank you for.
• Code Formatting and Linting: Complete Guide to Building Consistent Codebases
  • Master code formatting tools, linters, and establishing code style guidelines for consistent and maintainable codebases. Learn to set up automated workflows with pre-commit hooks and CI/CD.
• Code Review Best Practices: Effective Feedback and Collaboration
  • Master code review practices including giving and receiving feedback, conducting effective reviews, building positive review culture, and scaling reviews for team growth.
• Code Review Practices: Guidelines for Effective Code Reviews
  • A comprehensive guide to code review practices including review checklist, feedback guidelines, common issues, and building a positive review culture.
• Confidential Computing: Building Secure Enclaves and Privacy-First Systems
  • Master confidential computing with TEEs, secure enclaves, homomorphic encryption, and building privacy-first applications.
• Configuration Management: 12-Factor Apps and Beyond
  • Master configuration management for modern applications. Learn environment variables, config files, secret management, and building flexible configuration systems.
• Configuration Management: Environment Variables, Config Maps, and 12-Factor Apps
  • A comprehensive guide to configuration management including environment variables, config maps, secrets management, and the 12-factor app methodology.
• Configuration Management: Environment-Specific Settings
  • Master configuration management including environment variables, config files, feature flags, and building flexible configuration systems.
• Container Orchestration with Kubernetes: A Practical Guide
  • A comprehensive guide to Kubernetes including pod design, deployments, services, config management, and advanced patterns for production deployments.
• Container Orchestration: Kubernetes Deep Dive in 2026
  • Master Kubernetes architecture, deployment strategies, resource management, and advanced patterns for production workloads.
• Container Security: Best Practices for Secure Containers
  • Master container security including image scanning, runtime security, secrets management, and building secure containerized applications.
• Continuous Deployment Strategies: Blue-Green, Canary, and Progressive Delivery
  • Master modern deployment strategies including blue-green, canary, and progressive delivery. Learn to deploy safely with feature flags, rollback mechanisms, and observability.
• CQRS Pattern: Command Query Responsibility Segregation
  • Learn the CQRS pattern for building high-performance applications. Understand how to separate read and write operations, scale them independently, and optimize for different workloads.
• Data Mesh: Decentralized Data Architecture
  • Comprehensive guide to Data Mesh architecture, principles, and implementation for modern data platforms
• Data Pipeline Architecture: ETL, ELT, and Streaming Patterns
  • Build robust data pipelines with ETL, ELT, and streaming architectures. Learn Apache Airflow, Kafka, dbt, and real-time processing patterns for modern data engineering.
• Data Validation: Building Robust Input Handling
  • Master data validation patterns including schema validation, custom validators, and building comprehensive input validation systems.
• Database Connection Pooling: Optimizing Database Connections for High-Performance Applications
  • Master database connection pooling to improve application performance and scalability. Learn pool configurations, best practices, and common pitfalls.
• Database Connection Pooling: Performance at Scale
  • Master database connection pooling to handle thousands of concurrent requests without database exhaustion. Learn implementation patterns, configuration strategies, and troubleshooting techniques.
• Database Design Patterns: Repository, Unit of Work, and Data Mapper
  • A comprehensive guide to database design patterns including Repository pattern, Unit of Work, Data Mapper, and Active Record for building maintainable data access layers.
• Database Indexing Strategies: A Complete Guide
  • A comprehensive guide to database indexing — B-tree, hash, full-text, composite, and partial indexes — with query optimization techniques and real-world patterns.
• Database Indexing Strategies: Query Optimization Techniques
  • Master database indexing strategies to dramatically improve query performance. Learn B-tree, hash, GIN, and composite indexes with practical examples.
• Database Patterns: Caching, Sharding, and Scaling Strategies
  • Master database scaling patterns including caching strategies, horizontal sharding, read replicas, and performance optimization.
• Database Transactions: ACID Properties and Isolation Levels
  • Master database transactions with ACID properties, isolation levels, concurrency control, and practical patterns for building reliable database applications.
• Database Transactions: ACID Properties, Isolation Levels, and Concurrency Control
  • Master database transactions with ACID properties, isolation levels, and concurrency control. Learn transaction patterns, locking strategies, and distributed transaction patterns.
• Dependency Management: Security, Updates, and Version Control
  • Master dependency management strategies including security scanning, update automation, and maintaining healthy dependency trees.
• Design Patterns: Creational, Structural, and Behavioral Patterns
  • A comprehensive guide to classic design patterns including Factory, Singleton, Observer, Strategy, and how to apply them in modern Python applications.
• Developer Experience: The New Frontier of Software Engineering in 2026
  • Discover how organizations are prioritizing developer experience (DX) to boost productivity, reduce burnout, and attract top talent.
• Distributed Locking Patterns: Redis, etcd, and Coordination Services
  • Implement distributed locking with Redis, etcd, and ZooKeeper. Learn mutex patterns, leader election, and critical section protection for distributed systems.
• Distributed Tracing with OpenTelemetry and Jaeger
  • Comprehensive guide to distributed tracing, OpenTelemetry, Jaeger, and building observable microservices
• Distributed Tracing: Understanding System Behavior in Complex Architectures
  • Learn how distributed tracing helps debug performance issues, understand service dependencies, and monitor distributed systems.
• Distributed Transactions Patterns: SAGA, Two-Phase Commit, and Eventual Consistency
  • A comprehensive guide to distributed transaction patterns including SAGA pattern, two-phase commit, eventual consistency, and compensation mechanisms for microservices.
• Domain-Driven Design: Building Domain-Centric Applications
  • A comprehensive guide to Domain-Driven Design including entities, value objects, aggregates, repositories, and domain events for complex business logic.
• Domain-Driven Design: Strategic Software Architecture
  • Master Domain-Driven Design concepts including bounded contexts, entities, value objects, aggregates, and building domain-centric architectures.
• Edge Computing: Building Distributed Systems at the Network Edge
  • Master edge computing architecture including edge devices, fog computing, edge AI, and building responsive distributed applications.
• Error Handling Patterns: Building Resilient Applications
  • Master error handling strategies including exception patterns, error propagation, logging, and building user-friendly error responses.
• Error Handling Patterns: Building Resilient Applications
  • A comprehensive guide to error handling patterns including exception hierarchies, result types, retry logic, and circuit breaker patterns for robust applications.
• Event Sourcing: Building Systems Around State Changes
  • A comprehensive guide to event sourcing including event stores, aggregate reconstruction, snapshots, and CQRS patterns for audit-ready systems.
• Event Sourcing: Building Systems with Complete Audit Trails
  • Master event sourcing patterns including storing state as events, CQRS architecture, building systems with complete audit capability, and practical implementation strategies.
• Event-Driven Architecture: Building Responsive Systems with Events
  • A comprehensive guide to event-driven architecture including event sourcing, CQRS, message patterns, and practical implementation strategies for modern distributed systems.
• Event-Driven Architecture: Patterns and Implementation in 2026
  • Explore event-driven architecture patterns, message brokers, and implementation strategies for building scalable, resilient distributed systems.
• Feature Flags and Experiments: Controlled Feature Rollouts
  • Learn feature flag implementation, A/B testing, canary releases, and building a culture of experimentation.
• Feature Management: Flags, Rollouts, and Experimentation
  • Master feature flags, canary releases, A/B testing, and progressive delivery. Learn to ship faster, reduce risk, and experiment with confidence.
• FinOps: Engineering Cloud Cost Management at Scale
  • Master FinOps practices including cloud cost visibility, optimization strategies, showback/chargeback, and building cost-aware engineering cultures.
• GitOps 2.0: Progressive Delivery and Cloud-Native CD
  • Master GitOps 2.0 with progressive delivery strategies including canary deployments, feature flags, and advanced deployment patterns for Kubernetes.
• GitOps: The Future of Infrastructure and Deployment Management in 2026
  • Learn how GitOps is revolutionizing software delivery by using Git as the single source of truth for infrastructure and applications.
• Graph Databases: Modeling Complex Relationships
  • Comprehensive guide to graph databases, Neo4j, property graphs, and building connected data applications
• GraphQL API Design: Schema, Queries, and Best Practices
  • A comprehensive guide to GraphQL API design including schema design, query patterns, mutations, subscriptions, and performance optimization.
• gRPC and Protocol Buffers: High-Performance API Communication
  • Learn how gRPC and Protocol Buffers enable efficient, type-safe communication between services with up to 10x performance gains over REST APIs.
• Idempotency in Distributed Systems: Building Safe APIs
  • Learn how to design idempotent APIs that handle retries gracefully. Understand idempotency keys, optimistic locking, and practical implementation patterns.
• Incident Management: Building Effective On-Call and Response Practices
  • Learn incident management lifecycle, on-call best practices, post-mortems, and building a culture of reliability.
• Internationalization and Localization: Building Global Applications
  • Master i18n and l10n patterns including translation management, locale handling, and building applications for global audiences.
• Kubernetes Operators: Automating Complex Application Management
  • Learn how Kubernetes Operators extend K8s to manage complex applications. Build custom operators with Go or Python, implement reconciliation loops, and automate application lifecycle.
• Kubernetes Security: Securing Container Orchestration
  • Comprehensive guide to Kubernetes security, Pod Security Standards, RBAC, network policies, and securing containerized applications
• LLMOps: Operationalizing Large Language Models
  • Comprehensive guide to LLMOps: managing the complete lifecycle of LLMs from development to production
• Logging Best Practices: Complete Guide to Structured Logging for Production
  • Master structured logging, log levels, correlation IDs, and building a log management pipeline. Learn to write logs that help debug issues and maintain production systems.
• Logging Best Practices: Structured Logging for Production
  • Master structured logging, log levels, correlation IDs, and building a log management pipeline. Learn to write logs that help debug issues and maintain production systems.
• Low-Code and No-Code Platforms: Engineering Decisions and Integration
  • Master low-code/no-code platforms including architecture patterns, integration strategies, and building hybrid applications.
• Message Brokers: RabbitMQ, Kafka, and Distributed Messaging
  • Master distributed messaging with RabbitMQ and Kafka. Learn architecture patterns, implementation strategies, and how to build reliable message-driven systems.
• Message Queues: RabbitMQ, Kafka, and Async Communication
  • A comprehensive guide to message queues including RabbitMQ patterns, Kafka streaming, consumer groups, and async communication patterns.
• Message Queues: RabbitMQ, Kafka, and Event-Driven Systems
  • Master message queue architecture with RabbitMQ and Kafka. Learn patterns for building reliable asynchronous communication.
• Microservices Architecture: Principles, Patterns, and Best Practices
  • A comprehensive guide to microservices architecture including service decomposition, inter-service communication, data management, and operational considerations.
• Microservices Communication Patterns: REST, gRPC, and Event-Driven
  • Master microservices communication with synchronous REST, gRPC, and asynchronous messaging. Learn service discovery, load balancing, and fault tolerance patterns.
• Microservices Communication Patterns: REST, gRPC, and Event-Driven Messaging
  • A comprehensive guide to microservices communication patterns including synchronous REST, gRPC, asynchronous messaging, and hybrid approaches for distributed systems.
• Microservices Testing: Strategies for Distributed Systems
  • Master testing microservices including contract testing, integration testing, end-to-end testing, and building comprehensive test strategies for distributed systems.
• Microservices vs Monolith: Choosing the Right Architecture
  • Compare microservices and monolithic architectures, understand trade-offs, and learn when to choose each approach.
• Model Context Protocol (MCP): The Future of AI Integration
  • Master the Model Context Protocol (MCP) for building AI applications that can connect to external tools, data sources, and services.
• OAuth 2.0 and OpenID Connect: Modern Authentication and Authorization
  • Master OAuth 2.0 and OpenID Connect for secure authentication. Learn flows, token management, security best practices, and implementation patterns for modern applications.
• Observability Patterns: Logging, Metrics, and Tracing for Distributed Systems
  • A comprehensive guide to observability patterns including structured logging, Prometheus metrics, distributed tracing, and alerting strategies for microservices.
• Observability Stack: Building Comprehensive Monitoring
  • Learn to build a complete observability stack with metrics, logs, and traces. Master Prometheus, Grafana, and modern monitoring practices.
• Performance Optimization: Profiling and Optimization Techniques
  • Master performance profiling, identify bottlenecks, and apply optimization techniques to build fast applications.
• Performance Optimization: Profiling, Caching, and Scaling Strategies
  • A comprehensive guide to performance optimization including profiling techniques, caching strategies, database optimization, and horizontal scaling approaches.
• Platform Engineering: Beyond the Internal Developer Platform
  • Master modern platform engineering including developer experience, golden paths, self-service infrastructure, and building platform-as-a-product.
• Platform Engineering: Building Internal Developer Platforms in 2026
  • Learn how platform engineering teams create internal developer platforms (IDPs) to boost developer productivity and streamline software delivery.
• Prompt Engineering: Advanced Techniques for LLM Applications
  • Master prompt engineering techniques including chain-of-thought, tree-of-thought, ReAct, and building reliable LLM-powered applications.
• Rate Limiting and Throttling: Building Resilient APIs
  • Implement effective rate limiting and throttling strategies to protect your APIs from abuse, ensure fair usage, and maintain service reliability. Learn algorithms, implementation patterns, and best practices.
• Real-Time Event Processing with Apache Kafka
  • Comprehensive guide to building real-time event streaming applications with Apache Kafka
• RESTful API Design Best Practices: Building Production-Ready APIs
  • Best practices for designing RESTful APIs that are reliable, scalable, and developer-friendly. Covers naming conventions, response formats, versioning, and common patterns.
• Retrieval-Augmented Generation (RAG): Building AI Systems with Knowledge
  • Master RAG architecture including vector databases, embedding models, chunking strategies, and building production-grade knowledge retrieval systems.
• Search Engines: Elasticsearch, OpenSearch, and Modern Search Architecture
  • Build powerful search systems with Elasticsearch and OpenSearch. Learn full-text search, aggregations, scaling strategies, and real-world implementation patterns.
• Serverless Architecture: Building Event-Driven Applications
  • Master serverless computing with AWS Lambda, Azure Functions, and Google Cloud Functions. Learn patterns for building scalable event-driven applications.
• Service Mesh: Istio, Linkerd, and Beyond in 2026
  • Explore service mesh architectures, compare Istio and Linkerd, and learn how to implement zero-trust networking in Kubernetes.
• Service Mesh: Istio, Linkerd, and Modern Service Networking
  • Master service mesh architecture with Istio and Linkerd. Learn traffic management, security, observability, and how to implement zero-trust networking in microservices.
• Service Mesh: Istio, Linkerd, and mTLS for Microservices
  • A comprehensive guide to service mesh architecture including Istio, Linkerd, traffic management, mTLS, and observability for distributed systems.
• Site Reliability Engineering: SRE Principles and Practices in 2026
  • Master SRE principles including SLIs, SLOs, error budgets, and on-call practices to build reliable software systems.
• Software Architecture Documentation: ADRs, RFCs, and Technical Writing
  • Learn to document architecture decisions effectively using ADRs, RFCs, and create maintainable technical documentation.
• Software Architecture Patterns: Layered, Hexagonal, and Clean Architecture
  • Master software architecture patterns including layered, hexagonal, and clean architecture. Build maintainable and testable applications.
• Software Architecture Patterns: Layered, Hexagonal, and Clean Architecture
  • A comprehensive guide to software architecture patterns including layered architecture, hexagonal architecture, clean architecture, and when to apply each pattern in your projects.
• Software Design Patterns: Classic and Modern Applications
  • Master essential design patterns including creational, structural, and behavioral patterns with modern examples.
• Testing Strategies: Modern QA Practices in 2026
  • Explore comprehensive testing strategies including unit, integration, e2e, property-based testing, and shift-left approaches.
• Testing Strategies: Unit, Integration, and E2E Testing for Modern Applications
  • A comprehensive guide to testing strategies including unit tests, integration tests, E2E testing, test pyramids, and testing best practices for reliable software.
• Time Series Databases: InfluxDB, TimescaleDB, and Modern Data Storage
  • Comprehensive guide to time series databases, InfluxDB, TimescaleDB, and building modern monitoring applications
• Type Systems and Static Analysis: Building Safer Code
  • Master type systems, static analysis tools, and type checking to catch bugs before runtime.
• Vector Databases: The Foundation of AI-Powered Search
  • Comprehensive guide to vector databases, embedding-based search, and their role in modern AI applications
• Web Security: Complete Guide to Common Vulnerabilities and Prevention
  • Master web security vulnerabilities including XSS, CSRF, SQL injection, and OWASP Top 10. Learn to build secure applications and protect against modern threats.
• WebAssembly (Wasm): The Future of Portable, High-Performance Computing
  • Master WebAssembly including Rust/Go integration, WASI, browser applications, and building high-performance cross-platform software.
• Webhooks: Event-Driven Integration Patterns
  • Learn webhook implementation patterns for event-driven architectures. Build secure, reliable webhook systems with signature verification, retry logic, and delivery guarantees.
• WebSocket Programming: Real-Time bidirectional Communication
  • Comprehensive guide to WebSocket programming, implementation patterns, and building real-time applications
• Working with Configuration as Code: Infrastructure as Code Principles
  • Master infrastructure as code principles, tools like Terraform and Ansible, state management, module design, and building reliable infrastructure pipelines.
• Working with Dates and Times: Time Zones and Localization
  • Master date/time handling including time zones, localization, formatting, DST handling, and building internationally-aware applications in Python and JavaScript.
• Working with Files and Data Serialization: JSON, YAML, XML, CSV Complete Guide
  • Master data serialization formats including JSON, YAML, XML, and CSV. Learn when to use each format, handle large files efficiently, and choose the right format for your application.
• Working with Legacy Code: Strategies for Modernization
  • Learn strategies for improving, maintaining, and modernizing legacy codebases without disrupting business operations.
• Zero Trust Architecture: Beyond the Perimeter
  • Master zero trust security model including identity-based security, microsegmentation, continuous verification, and building resilient distributed systems.

software-engineering

• Agentic AI: Building Autonomous Software Agents in 2026
  • Learn how to build autonomous AI agents that can reason, plan, and execute complex tasks in 2026. Cover agent architectures, tool use, multi-agent systems, and production deployment.
• Architectural Decision Records (ADRs): A Complete Guide
  • Learn how to document and manage architectural decisions effectively. Includes ADR templates, tools, workflows, and real-world examples from modern software projects.
• Code Review Best Practices: A Complete Guide for Modern Teams
  • Master the art of code reviews with practical strategies, checklists, and automation. Learn how to give effective feedback, conduct constructive reviews, and build a culture of continuous improvement.
• Design Patterns for Modern Applications: A Comprehensive Guide
  • Master essential design patterns with practical examples in Python, JavaScript, and TypeScript. Learn creational, structural, and behavioral patterns with real-world applications.
• Multimodal AI Systems: Beyond Text in 2026
  • Explore multimodal AI systems that process text, images, audio, and video in 2026. Learn about vision-language models, audio AI, video understanding, and building integrated multimodal applications.
• Technical Debt Management Strategies: A Comprehensive Guide
  • Learn how to identify, track, quantify, and strategically manage technical debt in software projects. Includes practical frameworks, tools, and real-world examples.

Software-Engineering

• Engineering Ethics: Principles and Practices for Tech Professionals
  • A comprehensive guide to engineering ethics including core principles, real-world dilemmas, and frameworks for making ethical decisions in technology development.
• Software Architecture Patterns for Modern Applications
  • Learn essential software architecture patterns including microservices, event-driven, layered, hexagonal architecture, and when to use each approach.
• Software Architecture Patterns: A Practical Guide
  • Explore essential software architecture patterns including microservices, monoliths, event-driven, and layered architectures with implementation guidance and trade-offs.

If you find missing articles or inaccurate groupings, run ./scripts/update_index.py with appropriate flags.