Development Environments, Software Life Cycles, and Agile Methodologies

Comprehensive vocabulary flashcards covering development environments, life cycle models, CASE tools, programming paradigms, and agile methodologies including Scrum, Kanban, and Extreme Programming (XP).

Software

The intangible entity composed of computer programs that run on hardware to perform user tasks; an entire logical ecosystem encompassing system software, programming tools, and applications.

Program

A discrete functional unit of code written as a sequence of instructions in a programming language to execute a specific task, serving as an elementary operational component of software.

John von Neumann Architecture ($1946$)

The stored-program model establishing that hardware cannot operate without software and software cannot execute without a physical hardware structure.

Large Project Outcome Dynamics

Industry metrics showing that without formal planning, $26\%$ of large software projects achieve complete success, $48\%$ undergo drastic modification in costs, deadlines, or scope, and $26\%$ end in absolute failure.

Waterfall Model (Modelo en Cascada)

A classic, strictly linear software life cycle model where each stage must be fully completed before starting the next, lacking feedback loops and changes, which limits its use to extremely small projects.

Waterfall Model with Feedback (Cascada con Retroalimentación)

A sequential life cycle model that permits backtracking to earlier stages for debugging and corrections, suitable for rigid projects with stable and well-defined initial requirements.

Iterative Incremental Model

An evolutionary life cycle model designed for dynamic systems that continuously repeats and refines waterfall phases to propagate improvements across iterations.

Spiral Model (Modelo en Espiral)

An evolutionary life cycle model of high management complexity that combines incremental iteration with waterfall rigor, delivering successive versions of increasing functionality.

CASE Tools (Computer Aided Software Engineering)

Applications that automate software life cycle tasks to reduce time and costs while improving team productivity and product quality.

U-CASE (Upper CASE)

CASE tools designed to assist in the planning and analysis phases, focusing on requirements gathering and initial system conception (e.g., Use Case Maker).

M-CASE (Middle CASE)

CASE tools that support the analysis and design phases, focusing on defining structural, functional, and architectural models (e.g., ArgoUML).

L-CASE (Lower CASE)

CASE tools that support programming and testing phases, aiding in coding, bug detection, debugging, testing, and documentation (e.g., ObjectBuilder).

Rapid Application Development (RAD)

An iterative development process focused on the accelerated creation of prototypes using CASE tools, commonly applied today for rapid graphical user interface (GUI) construction.

Machine Language

Binary code composed of $0$s and $1$s, which is the only language directly understood by computer hardware; it is processor-dependent, non-portable, and rarely used for direct programming.

Assembly Language

A low-level language that replaces binary instructions with textual mnemonics while preserving direct ties to physical component addresses, requiring translation into machine code.

High-Level Language

A programming language using English sentences close to human reasoning that requires translation into machine code; a core group (Java, C, C++, PHP, Visual Basic) accounts for $60\%$ of global interest.

Structured Programming

A paradigm that restricts program flow to three control structures (sequential, selection, and loops), yielding simple and readable code whose monolithic format hampers maintenance in larger systems.

Modular Programming

An evolution of structured programming applying the 'divide and conquer' principle to segment software into independent, reusable functions or procedures (e.g., Pascal, C, Fortran).

Object-Oriented Programming (POO)

A dominant development paradigm commanding $55\%$ of the enterprise market, conceiving systems as collaborating independent objects that exchange messages.

Software Requirements Specification (ERS / SRS)

The formal document produced during the requirements analysis phase that details project objectives, planning, and functional as well as non-functional requirements.

Functional Requirements

Specifications detailing what actions the software must perform in response to specific inputs or operational conditions (e.g., barcode scanning, billing, inventory control).

Non-Functional Requirements

Specifications outlining quality criteria, constraints, and system parameters such as response times, legal standards, and concurrent user handling.

Source Code

Human-readable instructions written by developers in a high-level language, categorized as either open-source (free modification and access) or closed-source (proprietary).

Object Code (Bytecode)

An intermediate binary file produced by a compiler processing source code in a single pass; it is unintelligible to humans, not directly runnable on hardware, and only generated when source code is error-free.

Executable Code

A native machine binary file created by linking object code with required libraries via a linker, loaded directly into RAM by the operating system for execution.

Compiler

A translation tool that reads and converts the entire source code in a single batch to generate intermediate object code before execution.

Interpreter

A translation tool that parses and runs code line by line in real time without producing an intermediate object code file.

Virtual Machine (VM)

A software layer isolating applications from physical hardware to guarantee portability, handle memory management, and validate bytecode security.

Framework

A platform providing standardized templates, libraries, and tools to structure software construction; accelerates development but carries risks of vendor lock-in and resource overhead (e.g., .NET, Spring).

Java Runtime Environment (JRE)

An integrated execution environment for running Java applications, combining the Java Virtual Machine (JVM) interpreter and standard base API libraries.

Unit Testing

Isolated evaluation of individual functions or modules using test data and boundary values, frequently automated in Java environments via tools like JUnit.

Integration Testing

Comprehensive evaluation of the entire system with interconnected modules, including Beta Testing inside the client's actual production environment.

Technical Guide (Guía Técnica)

A document aimed at technical personnel (analysts and programmers) covering design specifications, source code architecture, and testing logs to facilitate maintenance.

User Guide (Guía de Uso)

A document aimed at end users and clients providing functional descriptions, execution modes, and practical operation examples.

Installation Guide (Guía de Instalación)

A document aimed at deployment IT personnel specifying system requirements, configuration parameters, and installation troubleshooting steps.

Perfective Maintenance

Software maintenance activities focused on optimizing the quality, speed, or performance of already existing functionalities.

Evolutionary Maintenance

Software maintenance activities focused on adding brand-new features requested by the client over time.

Adaptive Maintenance

Software maintenance activities aimed at altering the system to accommodate new market trends, platforms, or hardware changes.

Corrective Maintenance

Software maintenance activities focused on detecting and fixing operational bugs encountered during actual system usage.

Agile Manifesto ($2001$)

A foundational agreement drafted by $17$ software leaders establishing an adaptive development methodology focused on customer satisfaction, early functional deliveries, and team well-being.

Agile Optimal Conditions

Specific parameters where agile methodologies thrive: team sizes of $15$ to $20$ programmers, project durations of $5$ to $6\text{ months}$, face-to-face communication, and continuous client involvement.

User Story

A concise requirement described from the user's viewpoint using the standard template: 'As a [user type], I want [goal] so that [benefit]'.

Lean Software Development

A methodology complementary to Agile based on seven principles: eliminate waste, build quality in, create knowledge, defer commitment, deliver fast, respect people, and optimize the whole.

Scrum

An adaptive framework rooted in empiricism and Lean thinking that uses structured roles, events, and artifacts to resolve complex problems through iterative increments.

Sprint

A fixed iteration in Scrum lasting from $1$ to $4\text{ weeks}$ (normally $2\text{ weeks}$), during which a functional, usable product Increment is developed.

Product Owner

The Scrum role representing the customer and end users, tasked with determining delivery priorities and managing the Product Backlog.

Scrum Master

The Scrum role acting as a process facilitator who coordinates meetings and ensures that Scrum rules, events, and values are properly enacted.

Scrum Team

A self-organizing and cross-functional team of technical professionals responsible for executing the development work during a Sprint.

Product Backlog

A centralized, prioritized list containing all potential tasks, enhancements, and requirements that could be implemented in the product.

Sprint Backlog

The selected subset of Product Backlog items that the Scrum team formally commits to completing during an active Sprint.

Increment

The finished, functional, and tested deliverable produced at the end of a Sprint that cumulatively builds upon prior iterations.

Daily Stand Up

A daily $15\text{ min}$ Scrum synchronization meeting where team members review completed work, plan subsequent activities, and identify workflow blockers.

Kanban

An adaptive management method that optimizes continuous workflow on an existing process by displaying tasks on visual boards, enforcing WIP limits, and avoiding prescribed roles or sprints.

Work In Progress (WIP) Limits

Strict constraints placed on the number of simultaneous active tasks permitted in Kanban columns to minimize multitasking and eliminate bottlenecks.

Extreme Programming (XP)

An agile methodology focused on technical engineering excellence and sustainable team pace through very short cycles, pair programming, automated testing, and code refactoring.

Pair Programming

A technical practice in Extreme Programming where two engineers collaborate simultaneously at a single workstation to write code, provide real-time review, and solve problems jointly.