Quartz 4

Common ASP Question Topics Breakdown

4 min read

Common ASP Question Topics Breakdown

Most Frequently Asked Topics

  1. Memory Management Models (5 occurrences)

    • “Complex but Safe vs Simple but Unsafe Memory Management” appears in 4 different exams
    • Questions about memory safety approaches consistently appear across years

  2. Concurrency Mechanisms (5 occurrences)

    • “STM vs Message Passing for concurrency” appears in 3 different exams
    • Problems with message passing appears in 3 exams

  3. OS Implementation Languages (4 occurrences)

    • “Writing an OS in a strongly typed language” appears in 3 exams
    • “Writing an OS in a garbage collected language” appears in 3 exams

  4. Type-Driven Development (4 occurrences)

    • Questions about pros/cons and applications of type-driven development

  5. Async Programming (4 occurrences)

    • “Sync vs Async I/O” appears in 2 exams
    • Coroutines appears in 2 exams

Medium Frequency Topics

  1. Reference Management (3 occurrences)

    • “Mutable vs immutable references” appears in 2 exams

  2. Synchronization Problems (3 occurrences)

    • “Problems with locks/mutex in C++/Java” appears in 2 exams

  3. State Machines (3 occurrences)

    • Basic explanation and implementation approaches

  4. Threading Models (2 occurrences)

    • “Move from single threaded to multithreaded” appears in 2 exams

Less Common but Still Important Topics

  1. Security Concepts (2 occurrences)

    • Buffer overflow attacks
    • Address space layout randomization

  2. Type System Safety Features (2 occurrences)

    • Unsafe blocks in Rust
    • Option types vs null pointers

  3. Functional Programming (1 occurrence)

    • Application in systems programming

This breakdown highlights that the exam consistently focuses on memory management, concurrency models, type systems, and OS implementation considerations. These four areas should be your primary focus for revision.

Raw notes of each Question Title

2020 1a) Complex but Safe vs Simple but Unsafe Memory Management

2020 1b) Explain State Machines

2020 2a) Writing an OS in strongly typed language

2020 2b) Write an OS in a garbage collected language

2020 2c) Why dont we only using strongly typed languages in systems

2020 3a) Sync vs Async I/O

2020 3b) Coroutines

3c) Problems with message passing systems

2021 1a) STM vs Message Passing for concurrency

1b) Sync vs Async Message Passing

2a) Stack vs Heap

2b) Where is weak typing good and bad in C

2c) Why do we have unsafe blocks in rust

3a) Explain buffer overflow attack

3b) Explain address space layout randomisation

3c) Problems with postels law

3d) Type-driven development in security of systems

2022 1a) Move from single threaded to multithreaded (rise of concurrent programming)

2022 1b) Memory safety and security issues

1c) Complex but Safe vs Simple but Unsafe Memory Management

2a) Problems with locks/mutex in cpp and java

2b) STM vs Message Passing for concurrency

3a) Sync vs Async I/O

3b) Pros and Cons of type driven development

2023 1a) Move from single threaded to multithreaded

1b) mutable vs immutable message passing

1c) “let it crash” concurrency in systems programming

2a) Memory safety of direct memory casting

2b) expressive type systems and how they lead to better security

3a) Importance of direct memory control in systems programming

3b) mutable vs immutable references

3c) functional programming in systems programming

2024 1a) Value of unified memory models

1b) Write an OS in a garbage collected language

2a) Complex but Safe vs Simple but Unsafe Memory Management

2b) Why are casts unsafe

2c) Option types instead of null pointers

2d) enum vs struct state machines

3a) problems in message passing concurrency

3b) problems with async programming in rust

2019 1a) stack vs heap

1b) refernce counting for memory management

1c) mutable vs immutable references

1d) problems with reference counting

2a) problems with mutex and locks in cpp/java

2b) STM vs Message Passing for concurrency

3a) definition of a strong type system

3b) write an OS in a strongly typed language

3c) explain type-driven development

3d) Pros and Cons of extra complexity added by Type Driven Development

Sample Paper 1a) Complex but Safe vs Simple but Unsafe Memory Management

1b) Explain state machines

2a) Write an OS in a strongly typed language

2b) Write an OS in a garbage collected language

2c) Should we only write in strongly typed languages for systems programming?

3a) Benefits of Async I/O

3b) Coroutines

3c) problems with message passing concurrency

Graph View

Backlinks