Exercise topics
Topics are a rough way of describing which language/library features or techniques an exercise touches on.
An exercise has a topic if it forces the user to use techniques or language/library features or if it strongly hints at doing so.
The "YAML:" lines contain the syntax best used when using the tag in a .yml file.
Please keep the following in alphabetical order for quick lookup and add any topics to the quick reference.
- Abstract Data Types
- Arithmetic
- Arrays
- Bitwise-operations
- Conditionals
- Linked lists
- Loops
- Mappings
- Message passing concurrency
- Objects
- Pattern matching
- Recursion
- Regular expressions
- Shared state concurrency
YAML: "abstract data types"
Use of abstract data types, think Haskell's data keyword and Rust's enum.
YAML: "arithmetic"
The exercise involves more than basic arithmetic. For example exercises related to prime numbers have this topic since prime numbers are not trivial calculus.
YAML: "arrays"
Use of arrays. Arrays can be described as ordered collections in which access to every element takes an equal amount of time. Python's lists are thus arrays, not linked lists (which take less time for retrieving elements closer to the start).
YAML: "bitwise operations"
Use of bitwise operations such as bitwise and (& in many languages) and left shift (<<).
YAML: "conditionals"
Use of if-like constructs and switch-like constructs (such as Ruby's case).
YAML: "linked lists"
Use of (single or double) linked lists. In many functional and logic languages single linked lists are the common collection types. Note that Python's lists are not linked lists, they're more accurately described as arrays (and are usually implemented that way under the hood).
YAML: "mappings"
Use of mappings. Mappings are associative data structures also known as dictionaries, maps, objects (in Javascript) and hashes (in Perl/Ruby). If you have a data structure that supports looking up a value by some string key it's a mapping.
YAML: "message passing concurrency"
Use of message passing to implement concurrency (non-shared-state concurrency). For example Erlang messages and Go channels.
YAML: "objects"
Use of objects in an object-oriented sense. That is, objects encapsulate data so that the (only or preferred) way to manipulate the data is through methods on the object.
YAML: "pattern matching"
Use of pattern matching constructs like match in Rust or function argument matching in Elixir/Haskell.
YAML: "loops"
Use of loop constructs like for and while.
YAML: "recursion"
Use of directly or indirectly recursive calls. E.g. foo(n) calls foo(n-1).
YAML: "regular expressions"
Use of regular expressions (regexes).
YAML: "shared state concurrency"
Use of mutual exclusion locks (mutexes) or other synchronization mechanisms to allow multiple threads to access the same memory or resource.