Entering the software engineering world can feel like learning a foreign language. Between acronyms like PRD and CI/CD, and terms like "squashing" or "debugging," the jargon can quickly become overwhelming.
To help you navigate your first codebase, project meeting, and code review, we have compiled the ultimate developer glossary. We categorized these essential terms into five distinct phases of the software development ecosystem.
1. The Building Blocks of Code
These foundational terms represent the core logic, grammar, and structures you will interact with every single time you open a code editor.
- Variable: A named container used for storing data values.
- Data Type: The classification of data (e.g., String for text, Boolean for true/false, Integer for numbers).
- Syntax: The specific grammar and spelling rules of a programming language.
- Algorithm: A step-by-step set of instructions written to solve a specific problem.
- Function / Method: A reusable block of code that performs a specific task when called.
- Loop: A control structure used to repeat a block of code multiple times until a condition is met.
- Conditional: Statements like
if/elsethat allow code to make decisions based on certain conditions. - Bug: An error, flaw, or fault in a software program that causes it to behave unexpectedly.
- Debugging: The process of tracking down, isolating, and fixing bugs within code.
- Refactoring: Restructuring existing internal source code to improve readability and performance without changing its external behavior.
2. Basic Tools and Environments
Software development requires a specific ecosystem of applications and automated tools to help you write, translate, and manage your source files.
- IDE (Integrated Development Environment): A comprehensive software application providing code editors, compilers, and debuggers under one roof.
- Compiler / Interpreter: Programs that translate human-readable high-level code into machine-executable binary code.
- CLI (Command Line Interface): A text-based user interface used to interact with computer programs and systems via typed commands.
- Library: A collection of pre-written, reusable code snippets you can import to add specific features quickly.
- Framework: A structured architectural blueprint providing a foundation with built-in rules to build applications efficiently.
- Linter: An automated code quality tool that scans your code for style violations, syntax errors, and anti-patterns.
3. Architecture and the Web
These terms describe how software applications are structurally divided, how they store information, and how they communicate across the internet.
- Front-End: The client-side part of an application that users see and interact with directly.
- Back-End: The server-side part of an application that handles databases, logic, and background processing.
- Full-Stack: Development that covers both the front-end and back-end layers of an application.
- API (Application Programming Interface): A set of protocols that allows different software components or services to communicate with each other.
- API Documentation: A developer guide explaining how to format requests and handle responses when interacting with a specific API.
- Database: An organized, structured collection of data stored electronically for easy access and manipulation.
- HTTP / HTTPS: The protocol rules used for transferring data across the web between a browser and a server.
4. Product Strategy and Requirements
Before a single line of code is written, product and business teams use these documents and concepts to outline what needs to be built and why.
- PRD (Product Requirement Document): A comprehensive guide defining a product’s purpose, features, functionality, and success metrics for the development team.
- MRD (Market Requirement Document): A high-level document focused on market demand, competitor analysis, and target customer demographics.
- FRD (Functional Requirement Document): A highly detailed technical breakdown describing exactly how the system must behave to fulfill PRD goals.
- BRD (Business Requirement Document): A high-level overview outlining the strategic business goals, financial impacts, and overarching purpose of a project.
- MVP (Minimum Viable Product): The simplest version of a product released to users with just enough core features to gather early feedback.
- Scope: The defined boundaries of a project, specifying exactly what features will be built and what features are excluded from a specific milestone. Scope and milestone are also alternatively used for each other.
- Scope Creep: The uncontrolled expansion of a project's scope over time, usually due to adding unplanned features mid-development.
- Acceptance Criteria: An explicit checklist of conditions that a user story or feature must meet to be considered completed and correct.
- Success Metrics / KPIs: Quantifiable data points (like user sign-ups or page load speeds) used to measure if a feature is successful post-launch.
- User Flow: A visual diagram mapping out every sequential step a user takes to complete a specific task within the software.
5. Project Management and Lifecycle (SDLC)
Software development follows structured life cycles and agile frameworks to ensure teams stay organized and launch software predictably.
- Requirements Gathering: The initial SDLC phase where developers and stakeholders define exactly what the software must do.
- Architecture / Design: Creating the technical blueprint, including database schemas, system workflows, and user interface layouts.
- Implementation / Coding: The actual writing of the source code based on the design specifications.
- Testing / QA (Quality Assurance): Evaluating the software to find bugs and ensure it meets all original requirements.
- Deployment / Release: Shifting the finalized code to a live production server so actual users can access it.
- Maintenance: The ongoing process of fixing post-launch bugs, applying security patches, and adding minor optimizations.
- Waterfall: A traditional, linear project model where each phase must finish completely before the next phase begins.
- Agile: An iterative approach focusing on flexibility, collaboration, and delivering small software updates frequently.
- Scrum: A highly structured Agile framework featuring specific roles, short work cycles, and fixed-length meetings.
- Kanban: A visual Agile framework utilizing a physical or digital board to manage work-in-progress and optimize workflow.
- Product Backlog: A prioritized, master list of every feature, bug fix, and technical requirement needed for the project.
- User Story: A simplified description of a software feature written from the perspective of the end user (e.g., "As a user, I want to...").
- Epic: A large, complex body of work that can be broken down into several smaller user stories.
- Ticket / Issue: A digital record tracking a single specific task, bug, or feature request through a tool like Jira or GitHub.
- Velocity: A metric measuring the amount of work a development team successfully completes during an average sprint.
- Sprint: A designated, short timeframe (usually 1–4 weeks) in which a development team must complete specific tasks.
- Daily Standup / Scrum: A brief, daily 15-minute sync where team members share progress, upcoming plans, and any work blockers.
- Retrospective (Retro): A final team meeting held post-sprint to discuss what went well and what processes need improvement.
6. Git, Collaboration, and Code Reviews
Modern software is built by teams. Version control systems (like Git) allow multiple developers to work on the exact same codebase without breaking each other's work.
- Git: A decentralized Version Control System (VCS) used to track source code changes and collaborate with other developers.
- Repository (Repo): A central digital storage folder where your project's files and entire revision history live.
- Fork: A personal, complete copy of someone else's repository created on your account, typically used to contribute to open-source projects.
- Branch: An isolated parallel timeline created off the main codebase, allowing you to build features or fix bugs safely without affecting live code.
- Commit: A saved snapshot of local code changes, uniquely logged with a descriptive text message explaining what changed and why.
- Pull Request (PR) / Merge Request (MR): A submission packet requesting that your isolated code changes be reviewed and merged into the main project repository.
- Code Review: A collaborative peer-evaluation process where team members read through your PR to find bugs, suggest structural improvements, and check formatting.
- LGTM: A popular developer acronym for "Looks Good To Me", signaling that a reviewer approves of your PR code and it is ready to merge.
- Nit / Nitpick: A minor, non-critical comment or stylistic suggestion made during a code review that does not block the PR from being approved.
- Merge: The process of combining your branch's independent history and code changes back into the master/main production branch.
- Merge Conflict: A system error that triggers when two developers modify the exact same line of code independently, forcing a manual resolution before merging.
- Squash and Merge: A strategy that compresses a long history of multiple tiny commits into a single clean commit right as the PR merges.
- Rebase: A git strategy that reapplies your branch commits on top of the newest master branch updates, making the commit timeline linear and clean.
- Cherry-Pick: The act of selecting a single, specific commit from one branch and applying it directly to another branch without merging the whole timeline.
- Tech Spec (Technical Specification): An internal engineering document detailing the exact code structure, databases, and system architecture changes required.
- CI/CD (Continuous Integration / Continuous Deployment): Automation practices that continuously test, build, and deploy code changes to production smoothly.
- Feature Flag: A conditional toggle in the code allowing developers to turn a feature on or off remotely without redeploying code.
No comments:
Post a Comment