software-engineering - Concepts

Explore concepts tagged with "software-engineering"

Total concepts: 129

Concepts

Dummy Object - A test double passed around to fill parameter lists but never actually used, serving only to satisfy method signatures or constructor requirements.
Microservices Architecture - A distributed architecture style that structures an application as a collection of small, autonomous services organized around business capabilities.
Second-System Effect - The tendency for an engineer's second system to be over-engineered and bloated, as the designer includes all the features and ideas left out of the first system.
Dead Code - Source code that exists in a program but is never executed, has no effect on the output, or is unreachable.
Clean Code - Code that is easy to understand, maintain, and modify, following principles of readability, simplicity, and expressiveness.
Requirements Engineering - The systematic process of defining, documenting, validating, and managing software requirements throughout a project lifecycle.
Kubernetes - An open source container orchestration platform for automating deployment, scaling, and management of containerized applications.
Docker - A platform for developing, shipping, and running applications in lightweight, isolated containers that package code with all dependencies.
Software Analysis - The process of studying a software system to understand its requirements, structure, behavior, and constraints before design and implementation.
File System - A method and data structure used by operating systems to organize, store, retrieve, and manage files and directories on storage devices.
Vibe Coding - AI-assisted coding approach where developers guide AI agents through natural language to write and refine code.
Plain Text - Unformatted text without styling or proprietary encoding, ensuring maximum longevity and interoperability.
LazyGit - A terminal-based user interface (TUI) for Git that provides a visual, keyboard-driven way to perform Git operations.
GNU General Public License - A copyleft free software license that guarantees users the freedom to run, study, share, and modify software, requiring derivative works to be distributed under the same terms.
PostgreSQL - A powerful, open-source object-relational database management system known for reliability, extensibility, and standards compliance.
Premature Optimization - The practice of trying to improve code performance before it's necessary, often at the expense of clarity and maintainability.
Strangler Fig Pattern - A migration strategy that gradually replaces a legacy system by building new functionality alongside it until the old system can be decommissioned.
MIT License - A permissive open source license that allows almost unrestricted freedom to use, copy, modify, and distribute software with minimal conditions.
Continuous Delivery - A software development practice where code changes are automatically built, tested, and prepared for release to production, ensuring software can be deployed at any time.
Beads Viewer - A Terminal User Interface for browsing and managing tasks in projects using the Beads issue tracking system, with graph-aware dependency analysis.
Gource - An open-source software version control visualization tool that creates animated visualizations of source code repository history.
Lava Flow - An anti-pattern where dead or experimental code hardens into production systems and becomes difficult to remove.
Code Review - A quality assurance practice where one or more developers examine code written by a peer before it's merged into the codebase.
Unit Testing - A software testing practice where individual units of code are tested in isolation to verify they behave correctly and meet their specifications.
World Wide Web - An information system of interlinked hypertext documents and resources accessed via the Internet using web browsers.
The Mythical Man-Month - The Mythical Man-Month is Fred Brooks's seminal 1975 book arguing that the man-month is a dangerous myth because people and time are not interchangeable in complex software projects.
Request For Comments (RFC) - A document proposing changes or new ideas for collaborative review and feedback before implementation.
Clean Architecture - A software architecture pattern that emphasizes separation of concerns through concentric layers with dependencies pointing inward.
Domain-Driven Design - An approach to software development that centers the design on the core business domain and its logic.
Blameless Postmortem - An incident review practice focused on understanding what happened and improving systems rather than assigning blame to individuals.
Environment Variables - Named values maintained by the operating system or shell that configure process behavior, store system settings, and pass information between programs.
CAP Theorem - A theorem stating that distributed data stores can only guarantee two of three properties: Consistency, Availability, and Partition tolerance.
Apache License 2.0 - A permissive open source license that allows users to use, modify, and distribute software while providing an explicit patent grant and requiring preservation of copyright notices.
Open Source - Software whose source code is made publicly available for anyone to view, modify, and distribute, fostering transparency, collaboration, and innovation.
Worse Is Better - A software design philosophy arguing that simpler, 'worse' solutions often succeed over more complete but complex alternatives.
Pair Programming - An agile software development technique where two programmers work together at one workstation, sharing a single screen and keyboard.
Bash - A Unix shell and command language that serves as both an interactive command interpreter and a powerful scripting language.
Conway's Law - Organizations design systems that mirror their own communication structures.
Modulith - A modular monolith architecture that combines the simplicity of monoliths with the organizational benefits of microservices.
Python - A high-level, interpreted programming language known for its readable syntax and versatility, widely used in AI/ML, data science, web development, and scripting.
Bounded Context - A central pattern in Domain-Driven Design that defines explicit boundaries within which a domain model is defined and applicable.
Determinism - The principle that given the same inputs and initial conditions, a system or process will always produce the same outputs.
DevOps - A set of practices combining software development and IT operations to shorten the development lifecycle and deliver software continuously.
The Tar Pit - The Tar Pit is Fred Brooks's metaphor for why large-system programming is disproportionately harder than small programs, as scaling from a program to a programming systems product multiplies effort by roughly 9x.
Idempotency - A property where an operation can be applied multiple times without changing the result beyond the initial application.
Surgical Team - The Surgical Team is Fred Brooks's proposed team organization where a chief programmer handles all design decisions, supported by specialists who amplify productivity while preserving conceptual integrity.
Work In Progress (WIP) - An indicator that work is incomplete and not ready for final review or production use.
SQL - A domain-specific language for managing and querying relational databases.
Chaos Engineering - The discipline of experimenting on distributed systems to build confidence in their ability to withstand turbulent conditions.
YOLO Mode - A development approach where AI agents are granted broad execution permissions to work autonomously without per-action approval.
Software Requirements Specification - A comprehensive document that describes what a software system should do, including functional and non-functional requirements.
Database Management System - Software that manages databases, providing an interface between users/applications and data while handling storage, retrieval, security, backup, and concurrent access.
Essential vs Accidental Complexity - Essential complexity is the difficulty inherent in the problem being solved, while accidental complexity is the difficulty introduced by our tools, languages, and processes that can be reduced or eliminated.
Extreme Programming - An agile software development methodology that emphasizes technical excellence, continuous feedback, and close customer collaboration through practices taken to their logical extremes.
Async Development - A development workflow where tasks run in the background, allowing developers to work on multiple streams simultaneously.
Shell - A program that provides a command-line interface to interact with an operating system by interpreting user commands and executing them.
Requirements Elicitation - The process of gathering and discovering requirements from stakeholders through interviews, workshops, observation, and other techniques.
Supabase - An open-source Backend-as-a-Service (BaaS) platform often described as an open-source Firebase alternative, built on top of PostgreSQL.
TypeScript - A strongly-typed superset of JavaScript that adds static type checking and compiles to plain JavaScript, catching errors at development time rather than runtime.
Side Effects - Observable changes to state or interactions with the outside world that occur during the execution of a function or operation.
Plan More, Review Less - A development philosophy that emphasizes investing time in upfront planning to reduce the burden of reviewing completed work.
Ralph Wiggum Technique - An AI agent execution philosophy that embraces persistent iteration, where agents keep trying despite initial failures until they converge on working solutions.
Error Handling - The practice of anticipating, detecting, and responding to errors in software to maintain system stability and provide meaningful feedback.
Silent Failure - When a system fails without providing any visible indication, making problems difficult to detect and debug.
Integration Testing - A software testing practice where multiple components or modules are combined and tested together to verify they interact correctly as a group.
Release Early, Release Often - A software development philosophy advocating frequent releases to gather feedback and iterate quickly.
Debian - One of the oldest and most influential Linux distributions, known for its stability, free software commitment, and serving as the foundation for Ubuntu and many other distributions.
tmux - A terminal multiplexer that enables running multiple terminal sessions within a single window, with persistent sessions that survive disconnections.
Ralph TUI - A terminal user interface for orchestrating AI coding agents through autonomous task loops with intelligent selection, error handling, and real-time observability.
Defensive Programming - A coding practice that anticipates potential errors and edge cases, writing code that fails safely and provides clear error information.
LazyDocker - A terminal-based user interface (TUI) for managing Docker containers, images, volumes, and networks with an intuitive keyboard-driven interface.
Confused Deputy - A security vulnerability where a trusted program is tricked into misusing its authority on behalf of an attacker.
Test Double - A generic term for any object that replaces a production dependency during testing, including dummies, fakes, stubs, spies, and mocks.
Test Spy - A test double that records information about how it was called, allowing verification of interactions after the code under test has executed.
Conceptual Integrity - The principle that a system's design should reflect a unified, coherent set of ideas as if conceived by a single mind, which Brooks considered the most important consideration in system design.
Zsh - A powerful Unix shell that extends the Bourne shell with advanced features like enhanced tab completion, spelling correction, and extensive customization options.
Continuous Deployment - A software release practice where every code change that passes automated tests is automatically deployed to production without human intervention.
Internet - The global network of interconnected computer networks that enables worldwide communication and data exchange using standardized protocols.
Hypermedia - An extension of hypertext that incorporates multimedia elements like images, audio, video, and interactive content into linked information systems.
Behavior-Driven Development - A software development methodology that extends TDD by writing tests as human-readable specifications describing expected behavior from the user's perspective.
Use Cases - Descriptions of interactions between actors and a system to achieve specific goals, capturing functional requirements in a scenario-based format.
Ship It - A mindset and expression encouraging releasing software or work rather than endlessly refining it.
GitHub CLI - The official command-line tool for GitHub that brings pull requests, issues, and other GitHub features to your terminal.
Non-Functional Requirements - Requirements that specify quality attributes of a system such as performance, security, reliability, and usability.
Linux - A free and open-source Unix-like operating system kernel that powers the majority of web servers, cloud platforms, supercomputers, and Android devices.
Cascading Failures - A process where the failure of one component triggers sequential failures in dependent components, potentially leading to complete system collapse.
YAML - A human-readable data serialization format designed for configuration files and data exchange, using indentation-based structure instead of brackets or tags.
Terminal User Interface - A text-based user interface that runs within a terminal, providing interactive elements like menus, windows, and forms using text characters and ANSI escape codes.
JavaScript - A high-level, interpreted programming language that powers interactive web pages and modern applications across browsers, servers, and mobile platforms.
JSON - A lightweight, text-based data interchange format that is easy for humans to read and write, and easy for machines to parse and generate.
Semantic Versioning - A versioning scheme using MAJOR.MINOR.PATCH numbers to communicate the nature and impact of changes in software releases.
JSONL - A text format for storing and streaming structured data where each line is a valid JSON object, enabling efficient line-by-line processing without loading entire datasets into memory.
Rubber Duck Debugging - A debugging technique where explaining code line-by-line to an inanimate object helps identify the source of bugs.
Refactoring - The process of restructuring existing code without changing its external behavior to improve readability, maintainability, and design.
Test-Driven Development - A software development approach where tests are written before the code they validate, following a red-green-refactor cycle.
Working Directory - The directory in a file system that a process or shell session is currently operating in, commonly referenced via PWD or CWD.
Cone of Uncertainty - The principle that estimation accuracy improves as a project progresses and unknowns are resolved.
Mock Object - A test double pre-programmed with expectations about calls it should receive, used to verify interaction behavior between objects under test.
Relational Database Management System - A type of database management system that stores data in tables with rows and columns, using SQL for querying and the relational model for organizing data relationships.
Breaking Loudly - A software design principle where failures produce visible errors, exceptions, or warnings rather than silently continuing.
Plan to Throw One Away - Plan to Throw One Away is Brooks's advice that the first version of a system is essentially an experiment, so teams should explicitly plan for iteration rather than pretending the initial attempt will be the final product.
Literate Programming - A programming paradigm that treats programs as literature by interweaving human-readable documentation with executable code.
Functional Requirements - Requirements that specify what a system should do, including its features, capabilities, and behaviors.
HTTP - The foundational protocol of the World Wide Web that enables the transfer of hypertext documents and data between clients and servers.
Brooks's Law - Brooks's Law states that adding manpower to a late software project makes it later, because of ramp-up time, communication overhead, and task indivisibility.
Iterative Development - A software development approach that builds systems through repeated cycles of planning, building, testing, and refining.
Feature Flags - A technique allowing teams to modify system behavior without changing code by enabling or disabling features through configuration.
Distributed Systems - Computing systems composed of multiple independent components located on different networked computers that coordinate to achieve a common goal.
Software Estimation - The process of predicting the effort, time, or cost required to develop software, using various techniques to manage inherent uncertainty.
Test Stub - A test double that provides canned answers to calls made during a test, replacing real dependencies with predictable, pre-programmed responses.
Service-Oriented Architecture - An architectural style that organizes software as a collection of interoperable services that communicate through standardized interfaces.
Graphical User Interface - A visual interface that allows users to interact with software through graphical elements like windows, icons, buttons, and menus.
Software Entropy - The tendency of software systems to become increasingly disordered and complex over time without active maintenance.
Oh My Zsh - A community-driven framework for managing Zsh configuration that provides thousands of themes and plugins to enhance the command-line experience.
Unix - A family of multitasking, multi-user operating systems that originated at Bell Labs in 1969 and introduced foundational concepts that shaped modern computing.
No Silver Bullet - Fred Brooks's argument that no single technology or management technique can yield an order-of-magnitude improvement in software productivity, because the essential complexity of software is irreducible.
Test Fake - A test double with a working but simplified implementation that takes shortcuts unsuitable for production, such as an in-memory database.
Home Directory - A special directory assigned to a user account on a multi-user operating system, serving as the default location for personal files, configuration, and the starting point for shell sessions.
Blue-Green Deployment - A release strategy that reduces downtime and risk by running two identical production environments called Blue and Green.
Ubuntu - A Debian-based Linux distribution focused on ease of use and accessibility, making it the most popular desktop Linux distribution worldwide.
Monolithic Architecture - A software architecture pattern where an entire application is built as a single, unified unit.
DevSecOps - A DevOps approach that integrates security practices throughout the entire software development lifecycle, treating security as code.
Git Bash - A Bash emulation for Windows bundled with Git for Windows, providing a Unix-like command line experience on Windows systems.
Continuous Integration - A software development practice where developers frequently merge code changes into a shared repository, with each integration automatically verified by building and testing.
LangChain - An open-source orchestration framework for building applications with Large Language Models (LLMs).
Command Line Interface - A text-based interface where users interact with software by typing commands and receiving text output.
File Path - A string that specifies the location of a file or directory within a file system, expressed as either an absolute path from the root or a relative path from the working directory.
Pure Functions - Functions that always return the same output for the same input and produce no side effects.
Code Smell - Surface-level indicators in source code that suggest deeper problems in the design or implementation.

← Back to all concepts