reports/base.eval.json

{
  "model": "mlx-community/SmolLM-135M-Instruct-4bit",
  "adapter": null,
  "label": "base",
  "temperature": 0.0,
  "max_tokens": 48,
  "sets": {
    "memorization": {
      "total": 50,
      "correct": 3,
      "invalid": 10,
      "mc_total": 30,
      "mc_correct": 2,
      "recall_total": 20,
      "recall_correct": 1,
      "accuracy": 0.06
    },
    "heldout_sources": {
      "total": 50,
      "correct": 9,
      "invalid": 6,
      "mc_total": 30,
      "mc_correct": 7,
      "recall_total": 20,
      "recall_correct": 2,
      "accuracy": 0.18
    }
  },
  "items": [
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Set Encryption Key): Copy the key from ____ and set it to env, like so:\nWhich term fills the blank?\nA) {project_name}/config\nB) chat_room:\nC) .encryption_key\nD) .crystal-version\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) {project_name}/config\nB) chat_room:\nC) .encryption_key\nD) .crystal-version\nAnswer with a single letter.",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Working with Views): [Amber Generators](https://docs.amberframework.org/amber/cli/generate) support ____ and `ecr` templates using the `-t` option when creating a new project.\nWhich term fills the blank?\nA) slang\nB) redirect_to\nC) Dockerfile\nD) {project_name}/config/environments\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "The term filling the blank is `grammar/grammar/grammar/grammar/grammar/grammar/grammar/grammar/grammar/grammar/grammar/grammar/grammar/grammar",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (The Test Environment): In this case, we can modify our test environment by changing the options found in ____.\nWhich term fills the blank?\nA) Amber::WebSockets::ClientSocket\nB) config/environments/test.yml\nC) includes\nD) :checkbox\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "We can modify our test environment to fill the blank. The test environment is a configuration file that defines the environment variables for each test case. The test environment is created by adding the test case name to the file and defining the environment variables for",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (The `web` container): You can see the webpack configuration in the ____ directory to see what assets are compiled.\nWhich term fills the blank?\nA) config/database.yml\nB) channel.push\nC) .delete\nD) config/webpack\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "A) config/database.yml\nB) channel.push\nC) .delete\nD) config/webpack\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Introduction): * ____ - Called when a user leaves the channel.\nWhich term fills the blank?\nA) config/routes.cr\nB) with\nC) handle_leave\nD) Resources\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "Answer the questions in the following order:\nA) config/routes.cr\nB) with\nC) handle_leave\nD) Resources\nAnswer the questions in the following order:\nA) config/routes.",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Methods and Actions): Controllers are defined as such: As an example, if a user goes to ____ in your application to add a new client, Amber will create an instance of **ApiController** and call it's **index** method\nWhich term fills the blank?\nA) has_and_belongs_to_many\nB) save\nC) api/index\nD) config/\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) has_and_belongs_to_many\nB) save\nC) config/\nD) Controllers are defined as such: As an example, if a user goes to ____ in your application to add a",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Validation API): ____ Returns true if all params are valid or false otherwise.\nWhich term fills the blank?\nA) #valid?\nB) --back\nC) Amber::Router::File\nD) .delete\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "Validation API documentation for the #valid() method.\nValidation API documentation for the #valid() method.\n Invalid documentation for #valid() method.\n Invalid documentation for #valid() method.\n Invalid documentation for #valid() method.",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (docker-compose.yml): It includes the ____, `mailcatcher`, `migrate`, `app`, and `web` containers.\nWhich term fills the blank?\nA) database\nB) config/database.yml\nC) bin/{your-app-name}\nD) FormBuilder.form\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "The blank for which you're looking for a name is `database`. The correct name for `database` in `docker-compose.yml` is `database`. This is because `database` is a container, which means it can",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (From Source): Download and install ____ **NOTE:** At the time of this writing, v1.4.1 is the current stable release, but you should use the most recent tag in place of that.\nWhich term fills the blank?\nA) .buildpacks\nB) amber\nC) render\nD) chat_room\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) .buildpacks\nB) amber\nC) render\nD) chat_room\nAnswer with a single letter (A, B, or C).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Encrypted Environment Settings): **Never commit the encryption key!** Setup your production machine and use the variable ____ See more on [encrypt section](../cli/encrypt.md)\nWhich term fills the blank?\nA) chromedriver\nB) AMBER_ENCRYPTION_KEY\nC) _some_model_or_table_name__field_name\nD) chat_room\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) chromedriver\nB) AMBER_ENCRYPTION_KEY\nC) _some_model_or_table_name__field_name\nD) chat_room\nAnswer the blanks.\nA",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Finding Layouts): If there is no such controller-specific layout, Amber will use ____.\nWhich term fills the blank?\nA) @[NoInline]\nB) src/views/layouts/application.html.ecr\nC) secret_key_base\nD) user_join\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "The answer should be \"user_join\" because the controller-specific layout is used to define user-join actions. The controller-specific layout for user-join actions is:\n- @[NoInline]\n- user_",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Encrypted Environment Settings): This file is added to ____ to avoid inclusion in version control.\nWhich term fills the blank?\nA) .gitignore\nB) :web\nC) watch\nD) .delete\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "A) .gitignore\nB) :web\nC) watch\nD) .delete\nAnswer with a single letter (A, B, or C) is the correct answer. The answer is not provided here due to the ambiguity",
      "correct": true,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Working with Views): (Kilt will work with ____ and `temel` as well, but they haven't been tested in amber, so your experience may vary.) Kilt automatically selects the templating engine based on the extension of the file being read (e.g.\nWhich term fills the blank?\nA) mustache\nB) src/views/layouts/photos.ecr\nC) join\nD) distinct\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "Amber framework docs (Working with Views): (Kilt will work with ____ and `temel` as well, but they haven't been tested in amber, so your experience may vary.)\nKilt automatically selects the templating engine",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Validation API): ____ Input must be valid otherwise raises an error.\nWhich term fills the blank?\nA) --back\nB) create\nC) src/views/layouts/photos.ecr\nD) #validate!\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "Validation API: ____ Input must be valid otherwise raises an error.\nWhich term fills the blank?\nA) --back\nB) create\nC) src/views/layouts/photos.ecr\nD) #validate",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (The `mailcatcher` container): If you generate mailers, it will configure the ____ to point to the mail catcher container.\nWhich term fills the blank?\nA) @foo\nB) SMTP_URL\nC) AMBER_ENV\nD) ./microsecond-blog\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "The correct answer is A) @foo. The correct letter for the blank is A) @foo. The correct answer for the blank is B) SMTP_URL because the mailcatcher container is set to point to the mailcat",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Encrypted Environment Settings): With Amber you can encrypt your environment setting using `amber encrypt {environment}`, this command will open your editor to allow make changes if needed and then encrypt the file ____.\nWhich term fills the blank?\nA) pets\nB) gitignore\nC) {environment}.enc\nD) src/views/layouts/photos.ecr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "Amber framework docs (Encrypted Environment Settings): With Amber you can encrypt your environment setting using `amber encrypt {environment}`, this command will open your editor to allow make changes if needed and then encrypt the file ____.\nWhich",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Validation API): ____ Setup validation rules to be performed.\nWhich term fills the blank?\nA) AMBER_ENCRYPTION_KEY\nB) #validation\nC) config/routes.cr\nD) app/views/shared/_menu.html.ecr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "Validation API: ____Validation Rules to be performed.\nValidation Rules: ____Validation Rules to be performed.\nValidation Rules: ____Validation Rules to be performed.\nValidation Rules: ____Validation Rules to be performed.\nValidation Rules: ____",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Create Procfile): Create a ____ at the root of your Amber application and add the following: The Amber buildpack takes care of compiling the project for you.\nWhich term fills the blank?\nA) .first!\nB) Procfile\nC) button_to\nD) shards.yml\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "The term filling the blank is .first!. This term is used to indicate that the project is being compiled for you, which is crucial for the buildpack to function properly. The buildpack is a tool that compiles your project,",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Validation API): This array of errors is populated after running ____ or `#valid?`.\nWhich term fills the blank?\nA) has_many\nB) #validate!\nC) max\nD) crystallang/crystal:{version}\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "Validation API:\nValidation API:\n- The array of errors fills the blank.\n- The error array fills the blank.\n- The error array fills the blank.\n- The error array fills the blank.\n- The error",
      "correct": false,
      "invalid": true
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (docker-compose.yml): The ____ file will allow you to easily get up and running.\nWhich term fills the blank?\nA) .git/hook/post-receive\nB) params\nC) redirect_to\nD) docker-compose.yml\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "A) .git/hook/post-receive\nB) params\nC) redirect_to\nD) docker-compose.yml\nAnswer with a single letter (A, B, or C).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (FormBuilder in Plain Crystal Code): When using the ____ method in plain Crystal code, the `<<` syntax is required to add the generated field HTML to the form HTML string OR you can use the lower level `String.build` instead:\nWhich term fills the blank?\nA) belongs_to\nB) FormBuilder.form\nC) spec\nD) {project_name}/config/environments\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "The answer is A) belongs_to. The `<` syntax is required to add the generated field HTML to the form HTML string OR you can use the lower level `String.build` instead. The `<` syntax is required",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Custom): Then in your routes file: Alternatively you can use [____](../guides/controllers/respond-with.md) helper.\nWhich term fills the blank?\nA) database_url\nB) respond_with\nC) handle_message\nD) archived\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) database_url\nB) handle_message\nC) archived\nD) archived\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Dockerfile): It will also add the project to the ____ folder on the image so you can use this in production as well.\nWhich term fills the blank?\nA) Amber::Server\nB) src/views/layouts/photos.ecr\nC) /app\nD) lldb\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) Amber::Server\nB) src/views/layouts/photos.ecr\nC) /app\nD) lldb\nAnswer with a single letter (A, B, or C) for each term",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Resources): Let’s add a resource to the ____ Then go to the root of your project, and run `amber routes` This will output the standard matrix of HTTP verbs, controller, action, pipeline, scope, and URI pattern.\nWhich term fills the blank?\nA) bin/myapp\nB) config/routes.cr\nC) .distinct\nD) save\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) bin/myapp\nB) config/routes.cr\nC) .distinct\nD) save\nAnswer with a single letter (A, B, or C) as the correct answer.\nA) bin",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Transaction): To rollback a transaction, raise ____ exception.\nWhich term fills the blank?\nA) DB::Rollback\nB) has_many\nC) save\nD) postgres\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "Answer the blanks.\nA) DB:: Rollsback\nB) has_many\nC) postgres\nD) Postgres\nAnswer the blanks.\nA) DB:: Rollsback\nB) has_many\nC)",
      "correct": true,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (`amber new`): An ____ configuration file is generated a long with the default application directory structure.\nWhich term fills the blank?\nA) <repository>\nB) from\nC) .amber.yml\nD) index.ecr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) <repository>\nB) from\nC) .amber.yml\nD) index.ecr\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Resources): The ____ macro is a quick way to setup up resourceful routing for all seven standard actions for a controller in a single line.\nWhich term fills the blank?\nA) #remove_{{relation_name}}\nB) resources\nC) belong_to\nD) controllers\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) #remove_{{relation_name}}\nB) #remove_or_define_or_remove_or_define_or_remove_or_define_or_remove_or_define_or_remove_",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Define Buildpack): Create a file named ____ in the root of your project and with this: ```text https://github.com/amberframework/heroku-buildpack-amber.git\nWhich term fills the blank?\nA) distinct\nB) amber\nC) link_to\nD) .buildpacks\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "The correct answer is A) distinct. The term \"amber\" fills the blank because it is the only term that can be used to describe the identity of the file. The term \"buildpack\" fills the blank because it is the only",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (The Flash): Make sure the Flash, Session and CSRF pipelines are enabled in your ____ file and in the order that the scaffolding renders them.\nWhich term fills the blank?\nA) params\nB) index.ecr\nC) save\nD) routes.cr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "The correct answer is A) params. The pipeline for this is not enabled, so the correct name should be:\nA) params. The pipeline for this is not enabled, so the correct name should be:\nB) index.",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "mc",
      "question": "Amber framework docs (Add Amber dependency): First you require to add the ____ shard dependency in your `shard.yml` file: Then execute `shards install` :\nWhich term fills the blank?\nA) Amber.settings.secrets\nB) amber\nC) #add_{{relation_name}}\nD) {project_name}/config\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "The correct answer is A) Amber.settings.secrets. The correct answer is because the `@@@` notation is used to represent a relation, not a dependency. The `@@@` notation is used to represent",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Creating the database), which term completes this statement: Edit the database setting for your current environment by editing the file: Amber looks at the ____ key for the default database connection string. Answer with just the term.",
      "gold": "database_url",
      "completion": "The Amber web framework documentation explains that the default database connection string for Amber is the key. This means that you can edit the connection string to simply answer the term. For example, to edit the connection string to answer the term \"",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (6. Printing instance variables), which term completes this statement: For printing ____ var in this code: You can use `self.foo` in the debugger terminal or VSCode GUI. Answer with just the term.",
      "gold": "@foo",
      "completion": "We can use `Messing` to print the variable name. However, `Messing` is not a function, so it does not provide a way to print the variable name explicitly. Instead, we can use `Messing` to",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Set Encryption Key), which term completes this statement: Ensure you first run: To be able to decrypt and use production environment you'll need to set `ENV[\"AMBER_ENCRYPTION_KEY\"]` to the value of your local projects ____ file. Answer with just the term.",
      "gold": ".encryption_key",
      "completion": "You can use `SET_EXPAND_KEY` to check if `EXPAND_KEY` is a string, which is a Python function that takes a string as an argument and returns a boolean value. The `EXPAND_KEY",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Where), which term completes this statement: The ____ method accepts a block which represents the where clause of the query statement. Answer with just the term.",
      "gold": "where",
      "completion": "The Amber web framework documentation states that the ____ method accepts a block which represents the where clause of the query statement. This means that the statement is incomplete and incomplete, and the statement is incomplete in the sense that it does not complete the",
      "correct": true,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Scopes (aka. Prepared queries)), which term completes this statement: The ____ macro allows you to define a Crystal block containing the desired prepared query statement, and creates a class method on the model to execute. Answer with just the term.",
      "gold": "scope",
      "completion": "The Amber web framework documentation explains that the statement is completed by defining a class method on the model to execute. This means that the statement is executed when you define a class method, which is a way to define a method that takes a",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Distinct), which term completes this statement: ____ retrieves database column values without repeats. Answer with just the term.",
      "gold": ".distinct",
      "completion": "The Amber web framework documentation states that the term retrieves column values without repeats. This means that the column value is retrieved without any repetitions, as it is a single, unique value. The term retrieves column values is simply the column",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Tips and Tricks for debugging Crystal applications), which term completes this statement: ____ does not show data for variables in crystal yet, see issue [\\#4457](https://github.com/crystal-lang/crystal/issues/4457) Fully debugging Crystal applications is not supported yet. Answer with just the term.",
      "gold": "lldb",
      "completion": "Unfortunately, the Amber web framework does not support debugging Crystal applications. However, there are alternative approaches to debugging crystals, which can be used to check for data in variables in a specific context. One such approach is to use a debugger",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (The Amber Heroku Buildpack), which term completes this statement: If you need to use a specific version create a ____ file in your application root directory with the version that should be used \\(e.g. Answer with just the term.",
      "gold": ".crystal-version",
      "completion": "Unfortunately, the Amber web framework does not provide a way to create a file for this purpose. However, you can use a tool like `tmux-builder` to build a file for this purpose. Here's how to do it",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Callbacks), which term completes this statement: The available macros for defining callbacks include: * ____ * `after_save` * `before_create` * `after_create` * `after_initialize` * `before_destroy` They accept method names. Answer with just the term.",
      "gold": "before_save",
      "completion": "We can define a function `define_callbacks` that takes a string `term_name` as an argument and returns a function `define_callbacks` that takes a string `function_name` as an argument and returns a",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Group), which term completes this statement: ____ allows to add columns for `GROUP BY` section. Answer with just the term.",
      "gold": ".group",
      "completion": "The Amber web framework documentation for `GROUP BY` section states that the term should be `SUM` to complete the statement. This is because `SUM` is the most commonly used term in the Amber web framework documentation. Therefore",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Debug on VSCode), which term completes this statement: By convention the project directory name is the same as your application name, if you have changed it, please update `${workspaceFolderBasename}` with the name configured inside ____ Answer with just the term.",
      "gold": "shards.yml",
      "completion": "You can use `require-module` to check for a module name, and `require-module` to check for a module name within a module name. However, you can't use `require-module` to check for a module",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (File Mode), which term completes this statement: The changes you make will **not** modify the original source file, but they will be used when `amber exec` runs the code and saved as a ____ file. Answer with just the term.",
      "gold": "./tmp/{timestamp}_console.cr",
      "completion": "The statement \"The changes you make will not modify the original source file, but they will be used when `amber exec` runs the code and saved as a ____ file\" is not a true statement, as it is not a statement in",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Create Procfile), which term completes this statement: To deploy your app to Dokku you're going to need a ____. Answer with just the term.",
      "gold": "Procfile",
      "completion": "The Amber web framework documentation mentions that the term \"complete\" in this context means that the code should be able to handle all dependencies, including those that are not explicitly defined. In other words, the term should be able to handle all",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Define Crystal Version), which term completes this statement: Create a file named ____ in the root of your project with the wanted crystal version: Answer with just the term.",
      "gold": ".crystal-version",
      "completion": "The Amber web framework documentation defines a file named ____ as a file in the root of your project with the desired crystal version. This file is created when you open a project and its root directory. The file name is not explicitly mentioned,",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Eager load), which term completes this statement: Also you can extract the first entity via ____. Answer with just the term.",
      "gold": "first",
      "completion": "The Amber web framework documentation explains that the term \"__\" is used to complete this statement. The term \"__\" is used to complete the statement because it is a part of the statement, which means that it is a part of the statement",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Add A Jennifer Initializer to Configuration), which term completes this statement: Note that we pass the ____ to `Jennifer::Config.read` this will allow Jennifer to use the correct database settings for the environment. Answer with just the term.",
      "gold": "AMBER_ENV",
      "completion": "We can use `@Entity` to define a new entity and pass it to `EntityUtils.defineEntity`. Then, `EntityUtils.defineEntity` can be used to define a new entity and pass it to `EntityUtils.",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Finding Layouts), which term completes this statement: For example, rendering actions from the PhotosController class will use ____. Answer with just the term.",
      "gold": "src/views/layouts/photos.ecr",
      "completion": "The Amber web framework documentation mentions that the term \"complete\" in this context means that the action is completed, which means that the user can execute the action. In other words, the user can use the term \"complete\" to indicate",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (1. Install dependencies), which term completes this statement: If you already have ____, `amber`, and a database installed, you can [skip this step](#2.-generate-a-new-amber-application). Answer with just the term.",
      "gold": "crystal",
      "completion": "You can use `amber` to generate a new `amber` application by calling `amber-builder`. This will create a `amber` application, which can be used to create a `amber` application for `amber-builder`. The",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Resources), which term completes this statement: In order to use resourceful routing for a particular controller, your controller _must_ define and implement all seven standard actions: ____, `edit`, `new`, `show`, `create`, `destroy`, and `update`. Answer with just the term.",
      "gold": "index",
      "completion": "The Amber web framework documentation states that the term \"complete\" in this context is \"complete\" in this context. This means that the controller must complete all seven actions in order to use it effectively. The term \"complete\" in this",
      "correct": false,
      "invalid": false
    },
    {
      "set": "memorization",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (CSRF), which term completes this statement: To use CSRF, enable the pipe in your ____ by adding the following pipe to a pipeline. Answer with just the term.",
      "gold": "routes.cr",
      "completion": "Using the pipe notation in a string to indicate a completion of a string, like `<term>_<term>_<term>_<term>_<term>_<term>_<term>_<term>",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Create project structure): Then a basic setup \\(without views nor models\\) requires an ____ file inside `src/controllers` directory.\nWhich term fills the blank?\nA) debugger\nB) application_controller.cr\nC) database\nD) _some_model_or_table_name__field_name\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) debugger\nB) application_controller.cr\nC) database\nD) _some_model_or_table_name__field_name__defination\nAnswer with a single letter.\nA) debugger",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Including Jennifer in Server Bootstrap): The final step in configuration is to include Jennifer in your ____ file.\nWhich term fills the blank?\nA) distinct\nB) src/{project}.cr\nC) --release\nD) --back\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "In the context of configuration, Jennifer is indeed filling the blank. The correct answer is to include Jennifer in your server configuration. The definition of \"complete\" in this context is that Jennifer should be included in your configuration file to ensure that your",
      "correct": false,
      "invalid": true
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (The :layout Option): An example ____: And the layout `views/layouts/application.slang`: The `content` variable holds the rendered view that will be injected in the layout.\nWhich term fills the blank?\nA) views/home/index.slang\nB) postgresql\nC) /app\nD) max\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "A) views/layout/application.slang: The `layout` variable holds the rendered view that will be injected in the layout.\nB) views/layout/application/views/layout/application.slang: The `",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (In your production machine:): You can get your encryption key from ____ file in your development machine.\nWhich term fills the blank?\nA) index\nB) chat_room:\nC) save\nD) .encryption_key\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "A) index\nB) chat_room:\nC) save\nD) .encryption_key\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Redirection): A successful ____action, for instance, will usually redirect to the `show` action for the model we just created.\nWhich term fills the blank?\nA) config/environments/development.yml\nB) .then\nC) create\nD) settings.cr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) config/environments/development.yml\nB) .then\nC) show\nD) settings.cr\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Relations): * ____ - reload relation and returns it.\nWhich term fills the blank?\nA) ChatSocket\nB) postgresql\nC) #{{relation_name}}_reload\nD) save\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) ChatSocket\nB) postgresql\nC) #{{relation_name}}_reload\nD) save\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Relations): Jennifer provides 4 types of relations out of the box: ____, `belongs_to`, `has_and_belongs_to_many`, and `has_one`.\nWhich term fills the blank?\nA) has_many\nB) --back\nC) config/environments/development.yml\nD) rebroadcast!\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "A) has_many\nB) --back\nC) config/environments/development.yml\nD) rebroadcast!\nAnswer with a single letter.",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Using the Amber CLI on Heroku): When you deploy your project to heroku the amber build-pack will make available the `amber cli` to you via the ____ path.\nWhich term fills the blank?\nA) {project_name}/config/environments\nB) StaticController\nC) ./tmp/{timestamp}_console.cr\nD) bin/amber\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "A) {project_name}/config/environments\nB) Static Controller\nC) ./tmp/{timestamp}_console.cr\nD) bin/amber\nAnswer with a single letter (A, B, or C)",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Halt! and redirect\\_to): Unlike other frameworks Amber ____ stops the current execution of the request and performs the redirection at that given time.\nWhich term fills the blank?\nA) /spec\nB) @foo\nC) redirect_to\nD) config/initializers\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) /spec\nB) @foo\nC) redirect_to\nD) config/initializers\nAnswer with a single letter (A, B, or C) as the correct answer.\n####\nNo, the correct",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (If you need js / css compiled): https://github.com/heroku/heroku-buildpack-nodejs.git ``` If you want js / css to be compiled, you need to modify the ____ command in `package.json` to `\"build\": \"npm run release\",`.\nWhich term fills the blank?\nA) build\nB) config/application.cr\nC) weblog\nD) index.ecr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "Mock-Mock-Mock is a framework for mocking out of a package, which means it can be used to mock a package without the need for a full mocking framework like `MockRunner`. It is a framework that can be used to mock",
      "correct": false,
      "invalid": true
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (In your production machine:): Finally run your project executable with ____ .\nWhich term fills the blank?\nA) gitignore\nB) bin/<your-app>\nC) Amber::Server\nD) weblog\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) Gitignore\nB) bin/<your-app>\nC) Amber::Server\nD) Weblog\nAnswer with a single letter (A, B, or C).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Usage): In this example you would get the ____ response.\nWhich term fills the blank?\nA) gitignore\nB) html\nC) includes\nD) <repository>\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "In the context of a framework, the term \"blank\" can be used to describe the situation where a user has no response to a question. However, there are exceptions to this rule. For instance, in a framework like Django, the",
      "correct": false,
      "invalid": true
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Setting the current environment): As mentioned previously, Amber sets the application environment based on the ____ environment variable.\nWhich term fills the blank?\nA) AMBER_ENV\nB) join\nC) crystal\nD) Profile.all\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "The correct answer is A) AMBER_ENV. The confusion arises because the context of the question is not immediately clear. The context of the question is to determine whether to use the current environment variable or not, and whether to use a",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (The :template Option): This is the view template you would like to render, this could be of ____, `ecr`, `mustache`, or `temel`\nWhich term fills the blank?\nA) .crystal-version\nB) secret_key_base\nC) slang\nD) archived\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) .crystal-version\nB) secret_key_base\nC) slang\nD) archived\nAnswer with a single letter (A, B, or C)\nA) .crystal-version\nB)",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (In your production machine:): Install____ and `shards` commands \\([See installation guide](https://crystal-lang.org/docs/installation/)\\).\nWhich term fills the blank?\nA) amber\nB) first\nC) crystal\nD) http://www.mycoolsite.com/page\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "The correct answer is A) amber. The mistake in the original answer was that it used the word \"shards\" instead of the abbreviations \"shards\" and \"shards-based\" for each term. The correct answer should be",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Routing Parameters): Any other parameters defined by the routing, such as :id, will also be available in the ____ object.\nWhich term fills the blank?\nA) false\nB) openssl\nC) params\nD) render\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "Answer the questions correctly.\nA) false\nB) openssl\nC) params\nD) render\nAnswer the questions correctly.\nA) false\nB) openssl\nC) params\nD) render\nAnswer the",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Usage): If you do not specify a response type with the ____ header or using the dot notation in the url, you will get the first defined response type.\nWhich term fills the blank?\nA) rebroadcast!\nB) first\nC) accepts\nD) bin/amber\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) rebroadcast!\nB) first\nC) accepts\nD) bin/amber\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Granite): Granite also supports basic one-to-many relationships with ____ and `has_many` macros that will be familiar to developers experienced with ActiveRecord.\nWhich term fills the blank?\nA) belong_to\nB) shard.yml\nC) type\nD) openssl\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "A) belong_to\nB) shard.yml\nC) type\nD) openssl\nAnswer with a single letter (A, B, or C, or D).",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (File Upload): You can access files from the ____ macro using the `files` method.\nWhich term fills the blank?\nA) config/environments/development.yml\nB) params\nC) views/home/index.slang\nD) has_many\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) config/environments/development.yml\nB) params\nC) views/home/index.slang\nD) has_many\nAnswer the following questions using the provided dictionaries.\nA) What term fills the",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Redirection): Alternately, it could redirect to the ____ action to show all the things of that same type.\nWhich term fills the blank?\nA) Dockerfile\nB) handle_leave\nC) index\nD) #add_{{relation_name}}\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) Dockerfile\nB) handle_leave\nC) index\nD) #add_{{relation_name}}\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (STI): Single table inheritance can be used in this way: The subclass extends the superclass definition with new fields and uses string field ____ to identify itself.\nWhich term fills the blank?\nA) chromedriver\nB) type\nC) {project_name}/config/routes.cr\nD) config/environments/test.yml\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "A) chromedriver\nB) type\nC) {project_name}/config/routes.cr\nD) config/environments/test.yml\nAnswer with a single letter (A, B, or C,",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Relations): * ____ - adds given object to relation or builds it from has and adds.\nWhich term fills the blank?\nA) #add_{{relation_name}}\nB) src/controllers/hello_controller.cr\nC) chat_room:\nD) .buildpacks\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "A) #add_@: #add_@ is used to indicate that a relation is being added to a class. This notation indicates that the relation is being built from a class.\nB) src/controllers/hello_controller",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Delete and Destroy): ____ first loads objects and runs callbacks and then calls delete on each.\nWhich term fills the blank?\nA) rebroadcast!\nB) bin/myapp\nC) destroy\nD) api/index\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) rebound!\nB) bin/myapp\nC) destroy\nD) api/index\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Pipelines): With our ____ pipeline now define we can use it in our routes definitions.\nWhich term fills the blank?\nA) channel.push\nB) :web\nC) lldb\nD) {project_name}/config\nAnswer with a single letter (A, B, C, or D).",
      "gold": "B",
      "completion": "We define the pipeline as follows:\n|• :web\n| :project_name/config\n| :channel.push\n| :channel.push\n| :channel.push\n| :channel.push\n| :channel.",
      "correct": false,
      "invalid": true
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Validating request parameters): Amber attempts to alleviate the issues that come with invalid parameters and provides a ____ object to all controllers which contains a built-in `validation` method.\nWhich term fills the blank?\nA) slang\nB) gitignore\nC) :errors\nD) params\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "Validation of parameters in a framework like `Validating request parameters` can be done using a single letter, like `'('.` or `'('.` in a docstring. This notation ensures that the docstring only contains valid parameters,",
      "correct": false,
      "invalid": true
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Naming Partials): This holds true even when you're pulling in a partial from another folder: `<%= render \"shared/menu.html.ecr\" %>` That code will pull in the partial from ____.\nWhich term fills the blank?\nA) default\nB) .to_s\nC) database\nD) app/views/shared/_menu.html.ecr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "D",
      "completion": "A) default\nB) .to_s\nC) database\nD) app/views/shared/_menu.html.ecr\nAnswer with a single letter (A, B, or C, or D).",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (System Tests): Before running your specs ensure you have installed the ____ and that `selenium-server standalone` is in your system path.\nWhich term fills the blank?\nA) chromedriver\nB) #errors\nC) {project_name}/config/routes.cr\nD) slang\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "You are correct. The correct answer is `chromedriver`. The error message `Unknown module `chromedriver` is not supported by Selenium. To fix this, ensure you have installed `selenium-server standalone` in your",
      "correct": false,
      "invalid": true
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Add a new Route): Notice how after `\\chat`, the struct ____ that was created above is mapped to that route.\nWhich term fills the blank?\nA) .css\nB) ./tmp/{timestamp}_console.cr\nC) ChatSocket\nD) chat_room\nAnswer with a single letter (A, B, C, or D).",
      "gold": "C",
      "completion": "A) ./tmp/{timestamp}_console.cr\nB) .//tmp/{timestamp}_console.cr\nC) ChatSocket\nD) chat_room\nAnswer with a single letter (A, B, or C",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (If you need js / css compiled): Not defining a .buildpack file will cause Dokku to build your project using the ____ as Dokku will auto-detect it, this will not work and cause issues.\nWhich term fills the blank?\nA) Dockerfile\nB) bin/amber\nC) app/views/shared/_menu.html.ecr\nD) config/mailer.cr\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "A) Dockerfile\nB) bin/amber\nC) app/views/shared/_menu.html.ecr\nD) config/mailer.cr\nAnswer with a single letter.\n####\nNo, not",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "mc",
      "question": "Amber framework docs (Relations): * ____ - removes given object from relation.\nWhich term fills the blank?\nA) #remove_{{relation_name}}\nB) _some_model_or_table_name__field_name\nC) secret_key_base\nD) encryption_key\nAnswer with a single letter (A, B, C, or D).",
      "gold": "A",
      "completion": "The correct answer is A) _some_model_or_table_name__field_name. The confusion arises because the notation for a relation name can be ambiguous. The correct notation for a relation name is \"__model\" or \"__",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Update your project shard.yml), which term completes this statement: Once your Amber project is created, you will need to update your ____ file to include Jennifer as a dependency. Answer with just the term.",
      "gold": "shard.yml",
      "completion": "You can use the `@require` decorator to ensure that `@require(@require(@require(@require(@require(@require(@require(@require(@require(@require(@require(@require",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Pipelines), which term completes this statement: Don't get rid of ____ if you need to serve static assets. Answer with just the term.",
      "gold": "StaticController",
      "completion": "The Amber web framework documentation explains this statement as follows:\n$$Don't get rid of ____ if you need to serve static assets. Answer with just the term.$$\nThis statement means that you should not get rid of the term",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Filters), which term completes this statement: Filters are inherited, so if you set a filter on____, it will be run on every controller in your application. Answer with just the term.",
      "gold": "ApplicationController",
      "completion": "The Amber web framework documentation explains that the term \"complete\" in this context refers to the fact that the filter is executed on every controller in your application. This means that the filter will be executed for all controllers, not just those that",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Naming Partials), which term completes this statement: To render a partial as part of a view, you use the render method within the view: `<%= render \"menu\" %>` This will render a file named ____ at that point within the view being rendered. Answer with just the term.",
      "gold": "_menu.html.ecr",
      "completion": "The Amber web framework documentation explains that the term \"complete\" in this context refers to the completion of a partial. The term \"complete\" in this context means that the partial is fully completed, and the completion process is completed. This",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Update your project shard.yml), which term completes this statement: Add the following code snippet to your application's ____ file: ```yaml Answer with just the term.",
      "gold": "shard.yml",
      "completion": "We want to add the term `@require_require_require_require_require_require_require_require_require_require_require_require_require_require_require_require_require_require_require_require_",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Configuring Routes), which term completes this statement: Routes are configured in the ____ file. Answer with just the term.",
      "gold": "{project_name}/config/routes.cr",
      "completion": "The Amber web framework documentation explains that the term \"complete\" in this context refers to the completion of a specific task, which is a process that a program can complete. In this case, the task is to complete a specific route,",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Relation), which term completes this statement: To join a model relation such as ____, `belongs_to` and `has_one` you can pass it's name and join type as: Answer with just the term.",
      "gold": "has_many",
      "completion": "You can use `belongs_to` to join a model relation like `belongs_to(model)`. This notation simply means that `model` belongs to the relation. For example, `belongs_to(belongs",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Testing), which term completes this statement: You can ensure smooth testing by adding the following to your ____: Also just regular deleting or truncation could be used but transactions provide 15x speed up \\(at least for postgres; mysql gets less impact\\). Answer with just the term.",
      "gold": "spec_helper.cr",
      "completion": "You can ensure smooth testing by adding the following to your code:\n$$\n@@function @@function @@function @@function @@function @@function @@function @@function @@function @@function @@",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (File Upload), which term completes this statement: Files are detected and turned into ____ and put into a temporary file cache. Answer with just the term.",
      "gold": "Amber::Router::File",
      "completion": "The Amber web framework documentation explains this assertion as follows:\n$$ files_complete_cache$$\n$$ files_complete_cache$$\n$$ files_complete_cache$$\n$$ files_complete_cache$$\n$$ files_",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (The :layout Option), which term completes this statement: This will render the ____ template inside the `views/layouts/application.slang` layout. Answer with just the term.",
      "gold": "views/home/index.slang",
      "completion": "We can use the `TemplateHelper` class from the `TemplateHelper` package to achieve this. The `TemplateHelper` class provides a `TemplateHelper.TemplateHelper` instance, which can be used to create a template for a `",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Routing Parameters), which term completes this statement: We can add a route which captures the ____ parameter in a \"pretty\" URL: In this case, when a user opens the URL `/clients/active`, `params[:status]` will be set to \"active\" Answer with just the term.",
      "gold": ":status",
      "completion": "We can use `@@http_to_url` to construct a URL that captures the parameter `@@http_to_url:` in a `pretty` way. This notation ensures that the user can open the URL `/",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Relations), which term completes this statement: ____ also accepts the next 2 arguments and uses regular arguments in a slightly different way: * `join_table` - join table name; by default, relation table names are in alphabetic order, joined by underscores. Answer with just the term.",
      "gold": "has_and_belongs_to_many",
      "completion": "The Amber web framework documentation for `join_table` states that `join_table` accepts the next 2 arguments and uses regular arguments in a slightly different way. This means that `join_table` can accept any number of",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Setting the current environment), which term completes this statement: For example to run Amber in the production environment, we can set the ____ to `production`. Answer with just the term.",
      "gold": "AMBER_ENV",
      "completion": "We can use the `tmux-terminal-mode` to set the `tmux-terminal-mode` to `production`. This ensures that `tmux-terminal-mode` is set to `production` for all instances of",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Inline Mode), which term completes this statement: The ____ command in inline mode allows you to execute a line of code \\(or several with semicolons\\) with your application code and environment loaded. Answer with just the term.",
      "gold": "exec",
      "completion": "In inline mode, the term \\(or several with semicolons\\) is executed by executing the command \\(or several with semicolons\\) with your application code and environment loaded. This means that the command is executed when",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (In your development machine:), which term completes this statement: && npm run release` to compile/minify ____ and `.js` files. Answer with just the term.",
      "gold": ".css",
      "completion": "We can use `require-module` to compile and `require-module` to compile `release` files. The `require-module` function takes a module name as an argument and returns a module object, which in this case is",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (File Upload), which term completes this statement: The attributes you can access are: For example, let's say we have a controller with a ____ method that we want someone to `POST` a JSON body that includes a file to upload: ```crystal Answer with just the term.",
      "gold": "create",
      "completion": "The `@term` decorator in Python syntax is used to create a new function that takes a name as an argument. The decorator takes a name as an argument and returns a function that takes a name as an argument. The decorator can be",
      "correct": true,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Setting the current environment), which term completes this statement: If you would like to set the environment to something else, you will need to configure the ____ environment variable before running the server process. Answer with just the term.",
      "gold": "AMBER_ENV",
      "completion": "The Amber web framework documentation explains that the term \"complete\" in this context refers to the completion of a process, which means that the process is executed correctly. The statement \"complete\" in this context means that the process is executed correctly",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Editor Mode), which term completes this statement: Specifying a value for the ____ option allows you to go _n_ scripts back and edit+run that script. Answer with just the term.",
      "gold": "--back",
      "completion": "We can use the `tmux-mode-to-term` function to achieve this. Here's how:\n\n```tmux\ntmux-mode-to-term\ntmux-mode-to-term\ntm",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Setting the current environment), which term completes this statement: By default, the environment is set to ____. Answer with just the term.",
      "gold": "development",
      "completion": "The Amber web framework documentation explains that the term \"__\" is used to indicate that the environment is set to \"__\". This notation is used to indicate that the environment is set to a specific context, such as a list of dictionaries, which",
      "correct": false,
      "invalid": false
    },
    {
      "set": "heldout_sources",
      "kind": "recall",
      "question": "According to the Amber web framework documentation (Create project structure), which term completes this statement: Secondly a ____ file with pipelines and routes blocks, also see: [routing](../guides/routing/). Answer with just the term.",
      "gold": "routes.cr",
      "completion": "The statement \"Secondly a ____ file with pipelines and routes blocks\" is not a true statement, as it does not complete the statement. The statement is not a true statement because it does not complete the statement. The statement is true because it",
      "correct": false,
      "invalid": false
    }
  ],
  "wall_seconds": 14.6
}