Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Index

A
abstraction: abstraction
    accept: accept
      anonymous struct: anonymous struct
        argument coercion: argument coercion
          array: array
            autograde: autograde
              autograde results: autograde results
                B
                bit field: bit field
                  blueprint: blueprint
                    brute-force search: brute-force search
                      bubble sort: bubble sort
                        C
                        CRUD: CRUD
                          Classroom 50: Classroom 50
                            camel case: camel case
                              check: check
                                class: class
                                  class diagram: class diagram
                                    comma-separated values: comma-separated values
                                      compiler: compiler
                                        condition: condition
                                          creeper: creeper
                                            D
                                            Discussions: Discussions
                                              database: database
                                                database management system: database management system
                                                  database schema: database schema
                                                    declarative: declarative
                                                      decomposition: decomposition
                                                        deleting a file on GitHub: deleting a file on GitHub
                                                          diary: diary
                                                            dictionary: dictionary
                                                              divide and conquer: divide and conquer
                                                                do-while: do-while
                                                                  E
                                                                  EAFP: EAFP
                                                                    element: element
                                                                      end-of-file: end-of-file
                                                                        entity relationship diagram: entity relationship diagram
                                                                          enumerated type: enumerated type
                                                                            event-driven programming: event-driven programming
                                                                              F
                                                                              feedback template: feedback template
                                                                                file: file
                                                                                  file descriptor: file descriptor
                                                                                    flowchart: flowchart
                                                                                      for: for
                                                                                        foreign key: foreign key
                                                                                          forge: forge
                                                                                            function call stack: function call stack
                                                                                              function prototype: function prototype
                                                                                                G
                                                                                                Git: Git
                                                                                                  GitHub: GitHub
                                                                                                    GitHub organization: GitHub organization
                                                                                                      grade summary: grade summary
                                                                                                        graphical widget: graphical widget
                                                                                                          H
                                                                                                          hexadecimal: hexadecimal
                                                                                                            I
                                                                                                            instance: instance
                                                                                                              iteration: iteration
                                                                                                                J
                                                                                                                JSON: JSON
                                                                                                                  L
                                                                                                                  LBYL: LBYL
                                                                                                                    Legacy materials: Legacy materials
                                                                                                                      linked list: linked list
                                                                                                                        list comprehension: list comprehension
                                                                                                                          local variable: local variable
                                                                                                                            loop: loop
                                                                                                                              N
                                                                                                                              NoSQL: NoSQL
                                                                                                                                O
                                                                                                                                object-oriented programming: object-oriented programming
                                                                                                                                  octal: octal
                                                                                                                                    P
                                                                                                                                    PascalCase: PascalCase
                                                                                                                                      Power Query: Power Query
                                                                                                                                        package manager: package manager
                                                                                                                                          pass by reference: pass by reference
                                                                                                                                            pass by value: pass by value
                                                                                                                                              peer instruction: peer instruction
                                                                                                                                                pipeline: pipeline
                                                                                                                                                  pointer: pointer
                                                                                                                                                    polymorphism: polymorphism
                                                                                                                                                      primary key: primary key
                                                                                                                                                        principle of least privilege: principle of least privilege
                                                                                                                                                          procedural programming: procedural programming
                                                                                                                                                            R
                                                                                                                                                            RAPTOR: RAPTOR
                                                                                                                                                              REPL: REPL
                                                                                                                                                                radian: radian
                                                                                                                                                                  raylib: raylib
                                                                                                                                                                    recursion: recursion
                                                                                                                                                                      relational database: relational database
                                                                                                                                                                        release: release
                                                                                                                                                                          repository: repository
                                                                                                                                                                            row- and column-major order: row- and column-major order
                                                                                                                                                                              running total: running total
                                                                                                                                                                                S
                                                                                                                                                                                SQL: SQL
                                                                                                                                                                                  SQL injection: SQL injection
                                                                                                                                                                                    SQLite: SQLite
                                                                                                                                                                                      selection: selection
                                                                                                                                                                                        sentinel: sentinel
                                                                                                                                                                                          sequence: sequence
                                                                                                                                                                                            sequence (abstract data type): sequence (abstract data type)
                                                                                                                                                                                              serialization: serialization
                                                                                                                                                                                                set: set
                                                                                                                                                                                                  side effect: side effect
                                                                                                                                                                                                    snake case: snake case
                                                                                                                                                                                                      software reusability: software reusability
                                                                                                                                                                                                        spaced retrieval: spaced retrieval
                                                                                                                                                                                                          spacing effect: spacing effect
                                                                                                                                                                                                            stack overflow: stack overflow
                                                                                                                                                                                                              standard library: standard library
                                                                                                                                                                                                                storage class: storage class
                                                                                                                                                                                                                  stream: stream
                                                                                                                                                                                                                    struct: struct
                                                                                                                                                                                                                      structured program theorem: structured program theorem
                                                                                                                                                                                                                        T
                                                                                                                                                                                                                        tag: tag
                                                                                                                                                                                                                          tagged union: tagged union
                                                                                                                                                                                                                            token: token
                                                                                                                                                                                                                              two’s complement: two’s complement
                                                                                                                                                                                                                                U
                                                                                                                                                                                                                                Unified Modeling Language: Unified Modeling Language
                                                                                                                                                                                                                                  use case diagram: use case diagram
                                                                                                                                                                                                                                    V
                                                                                                                                                                                                                                    VSCodium: VSCodium
                                                                                                                                                                                                                                      variable-length array: variable-length array
                                                                                                                                                                                                                                        version control: version control
                                                                                                                                                                                                                                          W
                                                                                                                                                                                                                                          wireframe: wireframe
                                                                                                                                                                                                                                            Z
                                                                                                                                                                                                                                            zero-based numbering: zero-based numbering

                                                                                                                                                                                                                                              Glossary

                                                                                                                                                                                                                                              flowchart
                                                                                                                                                                                                                                              a type of diagram made of boxes and arrows that can be used to represent a process or algorithm. Flow chart
                                                                                                                                                                                                                                              repository
                                                                                                                                                                                                                                              (in context of version control systems) a data structure that stores metadata for a set of files or directory structure. The main purpose of a repository is to store a set of files, as well as the history of changes made to those files. Repository (data). Example: Git
                                                                                                                                                                                                                                              version control
                                                                                                                                                                                                                                              the software engineering practice of controlling, organizing, and tracking different versions in history of computer files; primarily source code text files, but generally any type of file. WP
                                                                                                                                                                                                                                              Git
                                                                                                                                                                                                                                              a version control software.
                                                                                                                                                                                                                                              forge
                                                                                                                                                                                                                                              a web-based collaborative software platform for developing and sharing software applications WP.
                                                                                                                                                                                                                                              GitHub
                                                                                                                                                                                                                                              a proprietary forge based on Git. https://github.com
                                                                                                                                                                                                                                              GitHub organization
                                                                                                                                                                                                                                              a shared GitHubaccount that belongs to the class. You will use it for your submissions and discussions. Our organization is https://github.com/dtucprog
                                                                                                                                                                                                                                              Classroom 50
                                                                                                                                                                                                                                              an open-source app for managing and grading assignments via GitHub[1]. Dashboard: https://classroom50.org,Documentation for students
                                                                                                                                                                                                                                              spaced retrieval

                                                                                                                                                                                                                                              a learning technique that is usually performed with flashcards. Effective for learning due to the spacing effect. Also known as spaced repetition. Spaced repetition

                                                                                                                                                                                                                                              Research shows that , for example using spaced retrieval, enables long-time learning as shown in Figure 1:

                                                                                                                                                                                                                                              Spaced retrieval practice supports keeping information in the long-term memory.
©️Felder, R., Brent R. Source

                                                                                                                                                                                                                                              Figure 1:Spaced retrieval practice supports keeping information in the long-term memory. ©️Felder, R., Brent R. Source

                                                                                                                                                                                                                                              spacing effect

                                                                                                                                                                                                                                              The spacing effect demonstrates that learning is more effective when study sessions are spaced out. Spacing effect

                                                                                                                                                                                                                                              diary

                                                                                                                                                                                                                                              a place where you collect your reflections about your learning experiences in the course

                                                                                                                                                                                                                                              Discussions

                                                                                                                                                                                                                                              The online board we use for online communication. https://github.com/orgs/dtucprog/discussions

                                                                                                                                                                                                                                              Legacy materials

                                                                                                                                                                                                                                              Previous version of course materials https://c-programming-legacy.aydos.de

                                                                                                                                                                                                                                              accept

                                                                                                                                                                                                                                              accepting an assignment in Classroom 50. It creates a repository which your instructor and you have access as default.

                                                                                                                                                                                                                                              deleting a file on GitHub

                                                                                                                                                                                                                                              You left click (open) the file you want to remove and then click the ... on the right side of your screen:

                                                                                                                                                                                                                                              Delete File button on the right below.

                                                                                                                                                                                                                                              Figure 2:Delete File button on the right below.

                                                                                                                                                                                                                                              Then, click Commit changes...

                                                                                                                                                                                                                                              check

                                                                                                                                                                                                                                              a program that runs in the background after you accept an assignment or do a change in your repository. An example is autograde.

                                                                                                                                                                                                                                              The autograde check has failed.

                                                                                                                                                                                                                                              The autograde check has failed.

                                                                                                                                                                                                                                              autograde

                                                                                                                                                                                                                                              a program that supports you and us to give feedback about your assignment. It usually consists of tests. Examples: testing whether the required files are present, testing whether your assignment outputs hello if hi is input.

                                                                                                                                                                                                                                              autograde results

                                                                                                                                                                                                                                              Refer grade summary

                                                                                                                                                                                                                                              grade summary

                                                                                                                                                                                                                                              autograde results can be seen by clicking Details on the respective check or clicking the last release.

                                                                                                                                                                                                                                              The test files-present have failed. In the details we see the reason: flowchart8.* could not be found.

                                                                                                                                                                                                                                              The test files-present have failed. In the details we see the reason: flowchart8.* could not be found.

                                                                                                                                                                                                                                              If a test fails, then do not blame yourself! The test itself may have mistakes too 🙂.

                                                                                                                                                                                                                                              release

                                                                                                                                                                                                                                              a version of your assignment which got submitted. The main page of your repository shows the last release:

                                                                                                                                                                                                                                              Releases section of your repository on GitHub. In this example it shows that you have submitted your assignment.

                                                                                                                                                                                                                                              Releases section of your repository on GitHub. In this example it shows that you have submitted your assignment.

                                                                                                                                                                                                                                              declarative

                                                                                                                                                                                                                                              Using text, you describe what a product, e.g, a diagram, program, should contain. The app figures out how to, e.g., draw it, write code, respectively.

                                                                                                                                                                                                                                              RAPTOR

                                                                                                                                                                                                                                              a flowchart-based programming environment. 📝Editor Website

                                                                                                                                                                                                                                              package manager

                                                                                                                                                                                                                                              software tool that automates the process of installing, upgrading, configuring, and removing computer programs in a consistent manner. Package manager

                                                                                                                                                                                                                                              It eliminates the problems with manual installations, which can be time-consuming and lead to errors.

                                                                                                                                                                                                                                              VSCodium

                                                                                                                                                                                                                                              an editor based on the popular text editor Visual Studio Code (VS Code).

                                                                                                                                                                                                                                              loop

                                                                                                                                                                                                                                              a control flow construct that performs iteration. Loop (statement)

                                                                                                                                                                                                                                              structured program theorem

                                                                                                                                                                                                                                              states that any program can be combined in only three ways to get any larger task done. Structured program theorem

                                                                                                                                                                                                                                              sequence

                                                                                                                                                                                                                                              executing one subprogram, and then executing another subprogram. drawing One of the big 3 of the structured program theorem.

                                                                                                                                                                                                                                              selection

                                                                                                                                                                                                                                              executing a subprogram based on a certain condition. One of the big 3 of the structured program theorem Structured program theorem

                                                                                                                                                                                                                                              iteration

                                                                                                                                                                                                                                              a step where some action is repeated again and again. Iteration. One of the big 3 of the structured program theorem.

                                                                                                                                                                                                                                              condition

                                                                                                                                                                                                                                              an (Boolean) expression that evaluates to either true or false.

                                                                                                                                                                                                                                              creeper

                                                                                                                                                                                                                                              a fictional creature from Minecraft. Creeper (Minecraft)

                                                                                                                                                                                                                                              feedback template

                                                                                                                                                                                                                                              The following widget can renders the top text in the DEMO tab below. You can edit the text to see how your rendered table will look like.

                                                                                                                                                                                                                                              You can use it later to give feedback to your peers.

                                                                                                                                                                                                                                              snake case

                                                                                                                                                                                                                                              or snake_case the process of writing compound words so that the words are separated with an underscore instead of space. Snake case

                                                                                                                                                                                                                                              camel case

                                                                                                                                                                                                                                              or camelCase, writing format practice of writing phrases with capitalized words and yet without spaces or punctuation. Camel case

                                                                                                                                                                                                                                              PascalCase

                                                                                                                                                                                                                                              initial upper camel case, e.g., OvenState, State Camel case#Variations and synonyms

                                                                                                                                                                                                                                              do-while

                                                                                                                                                                                                                                              If your flowchart is as follows:

                                                                                                                                                                                                                                              Then you can use a do-while.

                                                                                                                                                                                                                                              for

                                                                                                                                                                                                                                              Loop (statement)#Three-part for loop

                                                                                                                                                                                                                                              compiler

                                                                                                                                                                                                                                              a program that translates code written in one programming language into another. Compiler

                                                                                                                                                                                                                                              sentinel

                                                                                                                                                                                                                                              A value that interrupts the current process.

                                                                                                                                                                                                                                              Literally: a guard https://en.wiktionary.org/wiki/sentinel.

                                                                                                                                                                                                                                              zero-based numbering

                                                                                                                                                                                                                                              Zero-based numbering

                                                                                                                                                                                                                                              running total

                                                                                                                                                                                                                                              Running total

                                                                                                                                                                                                                                              side effect

                                                                                                                                                                                                                                              Side effect (computer science)

                                                                                                                                                                                                                                              Brute-force search

                                                                                                                                                                                                                                              divide and conquer

                                                                                                                                                                                                                                              Divide-and-conquer algorithm

                                                                                                                                                                                                                                              abstraction

                                                                                                                                                                                                                                              Abstraction (computer science) List of abstractions (computer science)

                                                                                                                                                                                                                                              decomposition

                                                                                                                                                                                                                                              Decomposition (computer science)

                                                                                                                                                                                                                                              software reusability

                                                                                                                                                                                                                                              Reusability

                                                                                                                                                                                                                                              local variable

                                                                                                                                                                                                                                              Local variable

                                                                                                                                                                                                                                              function prototype

                                                                                                                                                                                                                                              Function prototype

                                                                                                                                                                                                                                              argument coercion

                                                                                                                                                                                                                                              https://www.w3tutorials.net/blog/argument-coercion-in-c-c/

                                                                                                                                                                                                                                              function call stack

                                                                                                                                                                                                                                              Call stack

                                                                                                                                                                                                                                              stack overflow

                                                                                                                                                                                                                                              Stack overflow

                                                                                                                                                                                                                                              pass by value

                                                                                                                                                                                                                                              copying data and giving this as an argument to a function. Also called call by value: Evaluation strategy#Call by value

                                                                                                                                                                                                                                              pass by reference

                                                                                                                                                                                                                                              giving the address of the data as an argument to a function. Also called call by reference:Evaluation strategy#Call by reference

                                                                                                                                                                                                                                              enumerated type

                                                                                                                                                                                                                                              Enumerated type

                                                                                                                                                                                                                                              storage class

                                                                                                                                                                                                                                              C syntax#Storage class

                                                                                                                                                                                                                                              recursion

                                                                                                                                                                                                                                              Recursion (computer science)

                                                                                                                                                                                                                                              peer instruction

                                                                                                                                                                                                                                              Peer instruction

                                                                                                                                                                                                                                              end-of-file

                                                                                                                                                                                                                                              (EOF) End-of-file

                                                                                                                                                                                                                                              array

                                                                                                                                                                                                                                              Array data structure

                                                                                                                                                                                                                                              element

                                                                                                                                                                                                                                              a variable or value in context of an array

                                                                                                                                                                                                                                              variable-length array

                                                                                                                                                                                                                                              Variable-length array

                                                                                                                                                                                                                                              standard library

                                                                                                                                                                                                                                              the library that always comes with a language. Like a swiss army knife, it includes functionality most developers use. For example: libC standard library, Python standard library. Standard library

                                                                                                                                                                                                                                              EAFP

                                                                                                                                                                                                                                              easier to ask for forgiveness than permission. Preferred in Python. https://docs.python.org/3/glossary.html#term-EAFP

                                                                                                                                                                                                                                              LBYL

                                                                                                                                                                                                                                              look before you leap. Explicitly testing for pre-conditions before making any steps (leaps). Not preferred in Python but required in C. https://docs.python.org/3/glossary.html#term-LBYL

                                                                                                                                                                                                                                              pointer

                                                                                                                                                                                                                                              a variable whose value is a location in the computer’s memory. Pointer (computer programming)

                                                                                                                                                                                                                                              principle of least privilege

                                                                                                                                                                                                                                              Principle of least privilege

                                                                                                                                                                                                                                              radian

                                                                                                                                                                                                                                              a unit of measuring angles (symbol: rad). Whole rotation is 2π2\pi rad and a right angle (90°) is π/2\pi/2 rad. Radian

                                                                                                                                                                                                                                              sequence (abstract data type)

                                                                                                                                                                                                                                              a collection of items that are finite in number and in a particular order. List (abstract data type)

                                                                                                                                                                                                                                              list comprehension

                                                                                                                                                                                                                                              a syntactic construct for creating a list based on existing lists List comprehension

                                                                                                                                                                                                                                              dictionary

                                                                                                                                                                                                                                              a special kind of array, where each element has a name or label (key) instead of just a number (index). Also called associative array

                                                                                                                                                                                                                                              set

                                                                                                                                                                                                                                              a data type that stores distinct values, without any particular order. Set (abstract data type)

                                                                                                                                                                                                                                              serialization

                                                                                                                                                                                                                                              translating a data structure into a format that can be stored or sent over network. Also called marshalling, or flattening. Serialization

                                                                                                                                                                                                                                              object-oriented programming

                                                                                                                                                                                                                                              way of writing computer programs using objects to stand for data and methods. In contrast to writing a list of instructions for the computer, telling it to do certain things in a certain way, which is called procedural programming. Object-oriented programming

                                                                                                                                                                                                                                              procedural programming

                                                                                                                                                                                                                                              a language that follows instructions in a sequential manner. Mostly centered around functions. Procedural language

                                                                                                                                                                                                                                              blueprint

                                                                                                                                                                                                                                              a technical drawing which usually contains instructions for how to build an architecture or engineering design. Blueprint

                                                                                                                                                                                                                                              class

                                                                                                                                                                                                                                              basic building block in object-oriented programming defined to create an object. Analogy: blueprint. Class (programming)

                                                                                                                                                                                                                                              instance

                                                                                                                                                                                                                                              (or object). An object created from a class type Instance (computer science)

                                                                                                                                                                                                                                              Unified Modeling Language

                                                                                                                                                                                                                                              UML. A visual modeling language for visualizing the architecture and design of a system, similar to a blueprint. Unified Modeling Language

                                                                                                                                                                                                                                              class diagram

                                                                                                                                                                                                                                              describes the structure of a system by showing the system’s classes. Class diagram

                                                                                                                                                                                                                                              - means private, + public.

                                                                                                                                                                                                                                              use case diagram

                                                                                                                                                                                                                                              visualization of a user’s possible interactions with a system. Use case diagram

                                                                                                                                                                                                                                              Example Another example:

                                                                                                                                                                                                                                              Adapted Source

                                                                                                                                                                                                                                              bubble sort

                                                                                                                                                                                                                                              a simple sorting algorithm typically used in teaching. Bubble sort repeatedly steps through the input list element by element, comparing the current element with the one after it, swapping their values if needed until no swapping is needed. The larger elements “bubble” up to the top of the list. Bubble sort

                                                                                                                                                                                                                                              stream

                                                                                                                                                                                                                                              a sequence of potentially unlimited data elements made available over time, e.g., from a USB drive to computer’s main memory. Stream (computing)

                                                                                                                                                                                                                                              The three standard streams. Source

                                                                                                                                                                                                                                              The three standard streams. Source

                                                                                                                                                                                                                                              token

                                                                                                                                                                                                                                              a string that has been separated out from a larger text, and can be treated as a unit. Its meaning is assigned by whatever processes it. E.g., we can split “Hello world” sentence on the space character and get two tokens: “Hello” and “world”. We might then assign the word “Hello” the meaning greeting and world as a place name. Lexical analysis#Tokenization

                                                                                                                                                                                                                                              REPL

                                                                                                                                                                                                                                              read–eval–print loop. An interactive programming environment that takes single user inputs, executes them, and returns the result to the user. A.k.a interactive toplevel, language shell. https://en.wikipedia.org/wiki/Read–eval–print_loop

                                                                                                                                                                                                                                              struct

                                                                                                                                                                                                                                              (in C) A way to group different pieces of information together. Stands for structure. Struct

                                                                                                                                                                                                                                              tag

                                                                                                                                                                                                                                              a name that follows struct, union, or enum. in struct Person {}, Person is the tag. https://www.gnu.org/software/c-intro-and-ref/manual/html_node/Type-Tags.html

                                                                                                                                                                                                                                              linked list

                                                                                                                                                                                                                                              a data structure where each item links to the next item. Their order is not given by their physical placement in the memory like in arrays. Linked list

                                                                                                                                                                                                                                              tagged union

                                                                                                                                                                                                                                              a data structure used to hold a value that could take on several different types, where only one type can be in use. tag explicitly indicates which type is in use. Tagged union

                                                                                                                                                                                                                                              anonymous struct

                                                                                                                                                                                                                                              a C11 feature (compared to untagged structs). A member inside another struct with no member name, so its fields are accessed as if they belonged to the outer struct.

                                                                                                                                                                                                                                              bit field

                                                                                                                                                                                                                                              a data structure that maps to one or more adjacent bits with a specific purpose. Bit field

                                                                                                                                                                                                                                              raylib

                                                                                                                                                                                                                                              a video-game programming library https://www.raylib.com

                                                                                                                                                                                                                                              octal

                                                                                                                                                                                                                                              a numeral system that uses the numerals 0 through 7. Prefix 0 makes a number octal in C: 0100 = 64. Used to be more popular in early days of computers with character codes of 6 bits (old definition of byte), e.g., PDP-6, and with 12, 24, 36 bit architectures, e.g., PDP-8. Octal numbers still live in Unix file permissions. Octal

                                                                                                                                                                                                                                              hexadecimal

                                                                                                                                                                                                                                              a numeral system with 16 symbols, 0 to F. Hexadecimal

                                                                                                                                                                                                                                              two’s complement

                                                                                                                                                                                                                                              a way of storing negatives. https://simple.wikipedia.org/wiki/Signed_number_representations#2’s_complement

                                                                                                                                                                                                                                              file

                                                                                                                                                                                                                                              a means of store data that belongs together. Computer file

                                                                                                                                                                                                                                              file descriptor

                                                                                                                                                                                                                                              an integer index provided by the operating system (OS), that is linked to a file table. File descriptor

                                                                                                                                                                                                                                              JSON

                                                                                                                                                                                                                                              a data format. JSON

                                                                                                                                                                                                                                              polymorphism

                                                                                                                                                                                                                                              allows a value or variable to have more than one type and allows a given operation to be performed on values of more than one type. Derived from the principle in biology, where an organism can have many different forms or stages. Polymorphism (computer science)

                                                                                                                                                                                                                                              event-driven programming

                                                                                                                                                                                                                                              a method in which the program flow is determined by sensor outputs or user actions, e.g., mouse, keyboard. Event-driven programming

                                                                                                                                                                                                                                              graphical widget

                                                                                                                                                                                                                                              in GUIs: an element of interaction, such as a button or text field. Graphical widget

                                                                                                                                                                                                                                              wireframe

                                                                                                                                                                                                                                              screen blueprint. A visual guide that represents the graphical user interface. Website wireframe

                                                                                                                                                                                                                                              draw.io includes wireframe shapes. Click + More Shapes and activate Mockup

                                                                                                                                                                                                                                              database

                                                                                                                                                                                                                                              an organized collection of data or a type of data store based on the use of a database management system (DBMS) Database

                                                                                                                                                                                                                                              database management system

                                                                                                                                                                                                                                              the software that interacts with end users, applications, and the database.

                                                                                                                                                                                                                                              SQLite

                                                                                                                                                                                                                                              a lightweight database engine, and strictly speaking not a database management system like MySQL or PostgreSQL, but SQLite behaves similarly. SQLite

                                                                                                                                                                                                                                              SQL

                                                                                                                                                                                                                                              a language used to view or change data in databases. Structured Query Language

                                                                                                                                                                                                                                              SQL injection

                                                                                                                                                                                                                                              an attack, in which malicious SQL statements are inserted into a data entry field. SQL injection

                                                                                                                                                                                                                                              CRUD

                                                                                                                                                                                                                                              create, read, update, and delete — the four basic operations of storage. Create, read, update and delete

                                                                                                                                                                                                                                              relational database

                                                                                                                                                                                                                                              relational databases help users to join information to other information. In contrast to NoSQL databases. As of 2026, relational databases seem to be dominant[^stackoverflow-tech-data-2026]. Relational database

                                                                                                                                                                                                                                              NoSQL

                                                                                                                                                                                                                                              databases that do not use relations. In contrast to relational database. Used for distributed data with huge data storage like Facebook. NoSQL

                                                                                                                                                                                                                                              database schema

                                                                                                                                                                                                                                              the structure of a database in a formal language. Database schema

                                                                                                                                                                                                                                              primary key

                                                                                                                                                                                                                                              columns that can identify each individual row in a table in a relational database. Primary key

                                                                                                                                                                                                                                              foreign key

                                                                                                                                                                                                                                              attributes in a table that refers to the primary key of another table. Foreign key

                                                                                                                                                                                                                                              entity relationship diagram

                                                                                                                                                                                                                                              describes interrelations between tables in a database. We use crow’s foot notation. https://en.wikipedia.org/wiki/Entity–relationship_model#Related_diagramming_convention_techniques

                                                                                                                                                                                                                                              row- and column-major order

                                                                                                                                                                                                                                              methods for storing multidimensional arrays in computers. In row-major, the second row is stored after the first row, etc. Row- and column-major order

                                                                                                                                                                                                                                              Power Query

                                                                                                                                                                                                                                              a data transformation and preparation tool by Microsoft. Python in Excel uses Power Query to import external data. Power Query

                                                                                                                                                                                                                                              comma-separated values

                                                                                                                                                                                                                                              (CSV). Text data format for storing data you might find on a spreadsheet:

                                                                                                                                                                                                                                              name, age, city
                                                                                                                                                                                                                                              Ada, 37, Istanbul
                                                                                                                                                                                                                                              Bilal, 84, Oran

                                                                                                                                                                                                                                              Comma-separated values

                                                                                                                                                                                                                                              pipeline

                                                                                                                                                                                                                                              known from the Unix OS and available in all modern terminals. A mechanism for communication between programs. Pipeline (Unix)

                                                                                                                                                                                                                                              Footnotes
                                                                                                                                                                                                                                              1. Why Classroom 50 instead of DTU Learn? It eases the submission of Git-based projects for both the instructor and student. GitHub has many features, which lead to many mistakes for beginners. Classroom 50 locks many of these features and gives the ownership of the repositories to the instructor, which is one of the concrete advantages.