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
      argument coercion: argument coercion
        autograde: autograde
          autograde results: autograde results
            B
            brute-force search: brute-force search
              C
              Classroom 50: Classroom 50
                camel case: camel case
                  check: check
                    compiler: compiler
                      condition: condition
                        creeper: creeper
                          D
                          Discussions: Discussions
                            declarative: declarative
                              decomposition: decomposition
                                deleting a file on GitHub: deleting a file on GitHub
                                  diary: diary
                                    divide and conquer: divide and conquer
                                      do-while: do-while
                                        E
                                        enumerated type: enumerated type
                                          F
                                          feedback template: feedback template
                                            flowchart: flowchart
                                              for: for
                                                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
                                                              I
                                                              iteration: iteration
                                                                L
                                                                Legacy materials: Legacy materials
                                                                  local variable: local variable
                                                                    loop: loop
                                                                      P
                                                                      package manager: package manager
                                                                        pass by reference: pass by reference
                                                                          pass by value: pass by value
                                                                            peer instruction: peer instruction
                                                                              R
                                                                              RAPTOR: RAPTOR
                                                                                recursion: recursion
                                                                                  release: release
                                                                                    repository: repository
                                                                                      running total: running total
                                                                                        S
                                                                                        selection: selection
                                                                                          sentinel: sentinel
                                                                                            sequence: sequence
                                                                                              side effect: side effect
                                                                                                snake case: snake case
                                                                                                  software reusability: software reusability
                                                                                                    spaced retrieval: spaced retrieval
                                                                                                      spacing effect: spacing effect
                                                                                                        stack overflow: stack overflow
                                                                                                          storage class: storage class
                                                                                                            structured program theorem: structured program theorem
                                                                                                              V
                                                                                                              VSCodium: VSCodium
                                                                                                                version control: version control
                                                                                                                  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

                                                                                                                    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. In programming:

                                                                                                                    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

                                                                                                                    or call by value: Evaluation strategy#Call by value

                                                                                                                    pass by reference

                                                                                                                    or 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

                                                                                                                    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.