Glossary of Software Engineering Terms

Glossary of Software Engineering Terms

Use this glossary to look up common terms and definitions related to software engineering, software development, and computer programming. If you have any suggestions for terms to add, please contact me. This list is updated regularly.

1. Agile: A software development methodology that emphasizes iterative development, collaboration, and rapid response to change.

2. API (Application Programming Interface): A set of rules and protocols that allows different software applications to communicate with each other.

3. Assertion: A statement in code that checks if a condition is true and throws an error or exception if it's false.

4. Authentication: The process of verifying the identity of a user or system before granting access to resources.

5. Backlog: A prioritized list of tasks, features, or requirements that need to be completed in a software development project.

6. Big O notation: A notation used to describe the efficiency or complexity of an algorithm in terms of its input size.

7. Binary: A number system with a base of 2, consisting of only two digits: 0 and 1.

8. Bug: An error, flaw, or fault in software that causes it to behave unexpectedly or produce incorrect results.

9. Build: The process of compiling source code into an executable form or generating a deployable artifact.

10. CI/CD (Continuous Integration/Continuous Deployment): A software development practice that involves automatically building, testing, and deploying code changes to production environments.

11. Class: A blueprint or template for creating objects in object-oriented programming, defining their properties and behaviors.

12. Code review: A systematic examination of source code by developers or peers to identify defects, improve code quality, and ensure adherence to coding standards.

13. Compiler: A software tool that translates source code written in a high-level programming language into a lower-level representation, such as machine code or bytecode.

14. Continuous delivery: The practice of continuously delivering software changes to production environments in a rapid and reliable manner.

15. Cryptography: The practice of secure communication by converting plain text into unintelligible ciphertext and vice versa.

16. Database: A structured collection of data organized and accessed using a computer system.

17. Debugging: The process of identifying and fixing defects or problems in software.

18. Deployment: The process of making a software application available for use, typically on a server or production environment.

19. Design patterns: Reusable solutions to common problems in software design that help promote best practices and maintainability.

20. Docker: An open-source platform that allows applications to be packaged into containers, providing consistent and isolated environments for running software.

21. Encryption: The process of converting plaintext into ciphertext using algorithms and keys to secure data.

22. Endpoint: A specific URL or URI that an API exposes to allow clients to interact with the underlying resources or services.

23. Framework: A reusable set of libraries, components, and tools that provides a foundation for building software applications.

24. Frontend: The client-side portion of a software application that users interact with, typically built using HTML, CSS, and JavaScript.

25. Function: A self-contained block of code that performs a specific task or returns a value.

26. Git: A distributed version control system used for tracking changes in source code during software development.

27. GraphQL: A query language and runtime for APIs that allows clients to request and retrieve specific data from servers.

28. GUI (Graphical User Interface): A visual interface that allows users to interact with software using graphical elements, such as windows, buttons, and menus.

29. Hashing: The process of converting data into a fixed-size string of characters using a hash function, commonly used for data integrity and security.

30. IDE (Integrated Development Environment): A software application that provides comprehensive tools for writing, testing, and debugging code.

31. Infrastructure as Code (IaC): A practice of managing and provisioning infrastructure resources using code and configuration files.

32. Integration testing: A type of testing that focuses on verifying the interactions between different components or modules of a software system.

33. Interface: A contract or set of methods that define how a class or component can be used or interacted with.

34. JSON (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.

35. JVM (Java Virtual Machine): A virtual machine that provides an execution environment for running Java bytecode, allowing Java programs to run on different platforms.

36. Library: A collection of precompiled code modules or functions that can be used to extend and enhance software applications.

37. Linux: A free and open-source operating system kernel used in a wide range of computer systems, including servers and embedded devices.

38. Logging: The process of recording events, actions, and messages from a software application for troubleshooting, analysis, and auditing purposes.

39. Microservices: A software architecture style that structures an application as a collection of small, loosely coupled, and independently deployable services.

40. Middleware: Software components or services that sit between the application and the operating system, providing common functionality and services.

41. Mocking: The technique of creating fake or simulated objects to mimic the behavior of real objects during software testing.

42. MVC (Model-View-Controller): A software architectural pattern that separates the application logic into three interconnected components: the model, view, and controller.

43. Namespace: A mechanism for organizing code elements and preventing naming conflicts by defining distinct scopes.

44. Object-Oriented Programming (OOP): A programming paradigm that organizes software design around objects, which encapsulate data and behavior.

45. ORM (Object-Relational Mapping): A technique that allows data to be seamlessly mapped between relational databases and object-oriented programming languages.

46. Package manager: A tool or system that automates the process of installing, updating, configuring, and removing software packages or libraries.

47. Parallel computing: The practice of executing multiple tasks or processes simultaneously to improve performance and efficiency.

48. Performance testing: The process of evaluating the speed, responsiveness, scalability, and stability of a software application under specific workload conditions.

49. Polymorphism: A feature of object-oriented programming that allows objects of different types to be treated as objects of a common base type.

50. Prototyping: The process of creating a preliminary version or mockup of a software application to gather feedback and validate design decisions.

51. Pull request: A method for proposing changes to a codebase, typically within a version control system, where the changes are reviewed before being merged.

52. Push notification: A message or alert that is sent from a server to a mobile device or web browser, notifying the user of new information or events.

53. QA (Quality Assurance): The process of ensuring that a software product or system meets specified quality standards and requirements.

54. Refactoring: The process of restructuring existing code without changing its external behavior to improve its readability, maintainability, or performance.

55. Regression testing: A type of testing that ensures that changes or modifications in software do not introduce new bugs or issues in existing functionality.

56. REST (Representational State Transfer): A software architectural style that defines a set of constraints for creating web services that are scalable, stateless, and interoperable.

57. Scrum: An Agile framework for managing and organizing software development projects, involving small, self-organizing teams and time-boxed iterations called sprints.

58. Security testing: The process of evaluating a software system to identify vulnerabilities, weaknesses, and potential security risks.

59. Serverless: A cloud computing execution model in which the cloud provider manages the infrastructure and dynamically allocates resources as needed.

60. Software architecture: The structure and organization of a software system, including its components, modules, relationships, and principles.

61. Source code: The human-readable and writable representation of a software program written in a programming language.

62. SQL (Structured Query Language): A domain-specific language used for managing and manipulating relational databases.

63. Static analysis: The process of examining source code or software artifacts without executing them to find potential defects, security vulnerabilities, or code quality issues.

64. Test-driven development (TDD): A software development approach in which tests are written before the code, driving the design and ensuring code correctness.

65. Thread: A lightweight unit of execution within a process, allowing multiple tasks to run concurrently within an application.

66. UI (User Interface): The visual elements and controls that allow users to interact with a software application.

67. UML (Unified Modeling Language): A standardized modeling language used in software engineering to visually represent the design and structure of a system.

68. Unit testing: A level of testing where individual units or components of a software system are tested in isolation to ensure their correctness and functionality.

69. Usability testing: The process of evaluating a software application's user interface and user experience to ensure it is intuitive, efficient, and user-friendly.

70. User acceptance testing (UAT): The final phase of testing where end-users validate the software against their business requirements before its release.

71. User story: A brief, simple description of a software feature or requirement from the perspective of an end-user.

72. Version control: A system that tracks and manages changes to source code, allowing multiple developers to work on a project simultaneously and keep track of their modifications.

73. Virtualization: The process of creating a virtual representation of physical resources, such as servers or operating systems, to optimize resource utilization and enhance scalability.

74. Waterfall: A linear software development approach that progresses sequentially through defined phases, such as requirements gathering, design, development, testing, and deployment.

75. Web development: The process of creating web-based applications, websites, or services using technologies such as HTML, CSS, JavaScript, and server-side programming languages.

76. Wireframe: A visual representation or blueprint that outlines the structure, layout, and functionality of a software application's user interface.

77. XML (eXtensible Markup Language): A markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable.

78. Agile manifesto: A set of values and principles that guide the Agile software development approach, emphasizing individuals, collaboration, flexibility, and customer satisfaction.

79. Abstraction: The process of simplifying complex systems by breaking them down into manageable and understandable components.

80. Binary tree: A data structure in which each node can have at most two children, often used for efficient searching and sorting operations.

81. Concurrency: The ability of a system to execute multiple tasks or processes simultaneously, improving performance and resource utilization.

82. Design document: A formal document that describes the architecture, design decisions, and specifications of a software system.

83. Factory pattern: A design pattern that provides an interface for creating objects, allowing subclasses to decide which class to instantiate.

84. Garbage collection: The automatic process of reclaiming memory occupied by objects that are no longer in use, ensuring efficient memory management.

85. Inheritance: A mechanism in object-oriented programming where a class inherits properties and behaviors from a parent class, promoting code reuse and modularity.

86. Key performance indicator (KPI): A quantifiable measure used to evaluate the success or performance of a software project or system.

87. Load testing: The process of subjecting a software system to controlled and increasing workloads to evaluate its performance, scalability, and stability.

88. Machine learning: A field of artificial intelligence that focuses on developing algorithms and models that enable computers to learn and make predictions or decisions without explicit programming.

89. Multi-threading: The ability of an operating system or program to execute multiple threads concurrently within a single process.

90. Network protocols: Rules and conventions that define how data is transmitted and received over a network, ensuring proper communication between devices and systems.

91. Observability: The ability to monitor, measure, and understand the internal state and behavior of a software system through various instrumentation techniques.

92. Pair programming: A software development technique where two developers work together on the same code, with one actively coding and the other reviewing, guiding, and providing feedback.

93. Prototype: A working model or initial version of a software application used for testing, validating ideas, and gathering feedback before full-scale development.

94. Queue: A data structure that follows the First-In-First-Out (FIFO) principle, where elements are inserted at the rear and removed from the front.

95. Scalability: The ability of a software system to handle increasing workloads, users, or data without sacrificing performance, responsiveness, or stability.

96. Service-oriented architecture (SOA): An architectural style that structures software applications as a collection of loosely coupled, interoperable, and reusable services.

97. Software development lifecycle (SDLC): The process or methodology followed for designing, developing, testing, deploying, and maintaining software applications.

98. System testing: A comprehensive level of testing that evaluates the functionality, performance, and reliability of a complete software system.

99. User experience (UX): The overall experience and satisfaction that a user has when interacting with a software application, focusing on usability, accessibility, and enjoyment.

100. Vulnerability scanning: The process of identifying potential security vulnerabilities in software systems through automated scanning and analysis.

Supporting My Work

Please consider Buying Me A Coffee. I work hard to bring you my best content and any support would be greatly appreciated. Thank you for your support!

Eric David Smith

Father / Software Engineer / Musician / Entrepreneur