Software eng midterm 2

The high-level structure of the software, concerned with the overall organization of the software and how the components interact

Software Architecture

 The low-level structure of the software, concerned with the implementation of the individual components and how they interact.

Software Design

 The principle of dividing the issues involved in the program into different modules or classes, each of which is responsible for a specific aspect of the program.

Separation of Concerns 

    The principle that a module or class should have only one reason to change, or only one responsibility

Single Responsibility Principle 

     The idea that a module or class should conceal its internal state and behavior, exposing only the interfaces that are necessary for other modules or classes to interact with it

Information hiding 

The idea that a program should be divided into separate modules or classes, each of which is responsible for a specific aspect of the program

Modularity  

The idea that modules should interact with each other as little as possible, to make the program more maintainable and flexible

Loose Coupling    

    The idea that a module is focused on a single aspect of the program, making the program more maintainable and understandable.

High Cohesion 

  A standardized visual language for describing the structure and behavior of software systems through diagrams.

Unified Modeling Language (UML)   

  A UML diagram that describes a system from the outside, showing the actors that use it and the use cases (things they can do with it)

Use Case Diagram

  A UML diagram that describes the static structure of a system, showing its classes, their attributes and methods, and the relationships between them

Class Diagram   

 Common solutions to common problems in software design, such as the Singleton pattern, the Observer pattern, and the Strategy pattern.

Design Patterns  

A design pattern that ensures that only one instance of a class is created, and provides a way to access that instance.

Singleton Pattern 

A design pattern that allows multiple objects to listen for events and respond to them in a flexible way

Observer Pattern  

A design pattern that allows a class to change its behavior at runtime, by using different strategies.

Strategy Pattern  

   A design strategy that allows you to inject dependencies into a class, rather than creating them inside the class.

Dependency Injection 

The actual instructions that the computer executes to perform the desired functions

Code  

  The information that the software processes and manipulates

Data

The information that helps users understand and use the software.

Documentation     

The programs that install the software on a computer, mobile device, or server

Installers  

 How far removed a programming language is from the machine code that the computer executes

Level of abstraction   

  The style of programming that a programming language encourages

Paradigm  

How a programming language classifies values and expressions

Type system 

  A type system in which the types of values and expressions are known at compile time

Static typing   

 A type system in which the types of values and expressions are known at runtime

Dynamic Typing   

A type system in which the types of values and expressions are enforced by the language

Strong Typing     

A type system in which the types of values and expressions are not enforced by the language.

Weak Typing 

 Code that is easy to read, understand, and maintain

Clean Code 

 Code that is easy to modify, extend, and debug

Maintainable Code

 A set of rules that developers follow to ensure that code is written in a consistent style

Coding standards 

Software tools that help developers manage changes to source code over time

Version Control Systems 

  A collection of files and directories that make up a project.

Repository

 A snapshot of the code at a particular point in time

Commit     

A unique identifier for a commit

Commit Hash 

The sequence of changes that have been made to the code over time

Commit History    

   The main repository for a project.

Upstream Repository  

 Create a local copy of the code by copying the upstream repository.

Clone

 Share changes with other developers by sending them to the upstream repository

Push 

Update the local repository with changes from the upstream repository

Pull  

   A conflict that occurs when two or more developers make changes to the same code in an interleaved manner

Merge Conflict 

  A separate line of development that diverges from the main line of development

Branch    

a markup language for encoding documents in a format that is both human-readable and machine-readable

eXtensible Markup Language (XML)

 JavaScript Object Notation, a lightweight data-interchange format that is easy for humans to read and write and easy for machines to parse and generate

JSON 

a human-readable data serialization format that is commonly used for configuration files and data exchange

YAML Ain't Markup Language (YAML)

The process of making a software system available for use

Deployment  

 The context in which something exists or operates

Environment

 The context in which a system is deployed

Production Environment 

 The context in which a system is developed.

Development Environment

    A copy of the production environment that is used for testing before deploying to production.

Staging Environment 

  The way that a system's components are distributed across physical and virtual machines

Physical Architecture 

The way that a system's components are organized and interact with each other

Logical Architecture   

 The process of transforming source code into an executable program

Build

A package that includes the runnable application, as well as an installer program that guides the user through the installation process.

Installer   

A lightweight, standalone, executable package that includes everything needed to run a piece of software.

Container   

The methods, protocols, and data formats that components use to communicate with each other

Application Programming Interface (API)

 A computer or other device connected to a network allowing access to files, programs, or other resources

Host 

  Hosting that serves only static files (HTML, CSS, JavaScript)

Static Hosting  

  A virtual server that is hosted on a physical server, and that can be used to host web applications

Virtual Private Server (VPS)

  A cloud computing service that provides a platform for developing, running, and managing applications without the complexity of building and maintaining the infrastructure

Platform as a Service (PaaS)

The process of automating the deployment, scaling, and management of containerized applications.

Container Orchestration 

 The process of writing scripts (small programs) that perform the necessary tasks for deployment

Scripting  

   The process of defining the desired state of the production environment in code, and then automatically configuring the environment to match that state

Configuration Management   

The practice of automatically building and testing code whenever changes are made to the code repository

Continuous Integration (CI)  

   The process of managing the software artifacts that are produced during the build process

Artifact Management  

 A repository that stores software artifacts in a secure and reliable way

Artifact Repository    

A type of testing in which individual units or components of a software product are tested in isolation from the rest of the product

Unit Testing      

 A set of unit tests that cover all the important cases for a unit of the software

Test Suite 

A software development process that emphasizes writing tests before writing code

Test-Driven Development (TDD) 

   A software tool that helps developers write and run tests

Test Framework 

 A type of testing in which individual units or components of a software product are combined and tested as a group

Integration Testing    

 A software development practice in which developers integrate code into a shared repository frequently, often multiple times a day

Continuous Integration (CI)