373 lines
24 KiB
JSON
373 lines
24 KiB
JSON
{
|
|
"generated_at": "2026-04-01T13:53:41.169877",
|
|
"embedding_model": "bge-m3:latest",
|
|
"index_name": "avap-knowledge-v2-bge",
|
|
"result": {
|
|
"status": "ok",
|
|
"questions_evaluated": 50,
|
|
"elapsed_seconds": 447.0,
|
|
"judge_model": "claude-sonnet-4-20250514",
|
|
"index": "avap-knowledge-v2-bge",
|
|
"category_filter": "all",
|
|
"scores": {
|
|
"faithfulness": 0.54,
|
|
"answer_relevancy": 0.8509,
|
|
"context_recall": 0.5068,
|
|
"context_precision": 0.5661
|
|
},
|
|
"global_score": 0.6159,
|
|
"verdict": "ACCEPTABLE",
|
|
"details": [
|
|
{
|
|
"id": "GD-R-001",
|
|
"category": "RETRIEVAL",
|
|
"question": "What is AVAP and what is it designed for?",
|
|
"answer_preview": "AVAP (Advanced Virtual API Programming) is an Advanced Virtual API Programming language that is Turing Complete. It is designed to be used in the orquestation of microservices and I/O operations, with a focus on security, concurrency, determinism, and efficient processing of HTTP transactions, data ",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-002",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does the if() conditional block work in AVAP? How are blocks closed?",
|
|
"answer_preview": "In AVAP, the `if()` conditional block evaluates a logical or comparison expression. It requires an explicit closing statement using the command `end()`.\n\nBlocks within the `if()` function are closed with the following structure:\n```plaintext\n<block>\n <line>*\n</block>\n```\n\nThis is distinct from othe",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-003",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does AVAP handle external HTTP calls? What commands are available and how is timeout managed?",
|
|
"answer_preview": "AVAP handles external HTTP calls through the use of the `RequestPost` and `RequestGet` functions. These functions execute POST and GET requests, respectively, storing the response in a destination variable.\n\nTimeout management in AVAP involves using the `timeout` parameter to specify the amount of t",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-004",
|
|
"category": "RETRIEVAL",
|
|
"question": "How do functions work in AVAP? What is the scope of variables inside a function?",
|
|
"answer_preview": "In AVAP, functions are enclosed within a recital of memory. When entering a function, AVAP creates a new dictionary of local variables isolated from the global context.\n\nVariables defined in the **Function Scope** can be accessed by other parts of the program or by other functions that call this one",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-005",
|
|
"category": "RETRIEVAL",
|
|
"question": "What are the three types of variable scopes in AVAP and what are their visibility rules?",
|
|
"answer_preview": "In AVAP, there are three types of variable scopes:\n\n1. **Global Scope**: Variables declared at the top level or outside any function.\n2. **Main Local Scope**: Variables declared within the `main` function.\n3. **Function Scope**: Variables declared inside a function.\n\nEach type has specific visibilit",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-006",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does concurrency work in AVAP? What are goroutines and how are they launched?",
|
|
"answer_preview": "Concurrency in AVAP is managed through the concept of **goroutines**. Goroutines are lightweight threads that can be created using the `go` keyword, similar to creating a function call.\n\n```avap\ngo funcion()\n```\n\nGoroutines follow the same scope rules as normal functions:\n\n- They can access the **Gl",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-007",
|
|
"category": "RETRIEVAL",
|
|
"question": "What is the addParam command and how does it capture HTTP request parameters?",
|
|
"answer_preview": "The `addParam` command inspects a given HTTP request in an ordered, strict hierarchy: first in the URL (Query arguments), then in the JSON body, and finally in the form data. If the requested parameter does not exist, the variable destination is initialized as `None`.\n\nFor example:\n```plaintext\naddP",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-008",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does the startLoop / endLoop construct work in AVAP?",
|
|
"answer_preview": "The `startLoop` and `endLoop` constructs are used to iterate over a range of indices, similar to Python's `range` function. The loop variable is incremented by 1 at each iteration.\n\n```plaintext\nstartLoop(idx, 0, 2)\n actual = registros[int(idx)]\nendLoop()\n```\n\nThis code snippet iterates over the ",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-009",
|
|
"category": "RETRIEVAL",
|
|
"question": "What is the addResult command and how does it build the HTTP response?",
|
|
"answer_preview": "The `addResult` command in AVAP is used to register variables that will form part of the JSON body of the final response. It allows for specifying both the status code directly (`_status = 404`) or through a function call (`addVar(_status, 401)`).\n\nIn the provided context, `addResult(acceso)` is cal",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-010",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does error handling work in AVAP with try() and exception()?",
|
|
"answer_preview": "In AVAP, error handling is managed using the `try()` function. When an error occurs within a `try` block, it triggers the execution of the following code:\n\n```python\nexception(e)\n addVar(_status,500)\n addResult(\"Error de base de datos\")\n```\n\nThis sequence of actions happens when an exception i",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-011",
|
|
"category": "RETRIEVAL",
|
|
"question": "What is the replace() command in AVAP and how is it used?",
|
|
"answer_preview": "The `replace()` command in AVAP is a function that replaces occurrences of a specified substring with another substring within a string. It is commonly used to modify strings by replacing certain characters or patterns.\n\nIn the provided context, the `replace()` command is used as follows:\n\n1. The fi",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-012",
|
|
"category": "RETRIEVAL",
|
|
"question": "What are the reserved keywords in AVAP that cannot be used as identifiers?",
|
|
"answer_preview": "In AVAP, the following keywords are considered reserved and cannot be used as identifiers:\n\n- `_status`",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-013",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does AVAP handle string formatting and concatenation?",
|
|
"answer_preview": "AVAP supports string formatting through the use of placeholders in expressions. For example, you can format strings by using curly braces `{}` with variables or expressions inside them:\n\n```plaintext\n\"Hello, {}! Your age is {} years old.\"\n```\n\nWhen this expression is evaluated, it will replace `{}` ",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-014",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does the encodeSHA256 command work in AVAP?",
|
|
"answer_preview": "The `encodeSHA256` command in AVAP is used to generate a SHA-256 hash of a given payload data. This function takes two parameters: the payload data and a checksum, which are combined using the SHA-256 algorithm to produce a fixed-size output.\n\nHere's how it works:\n\n1. The `encodeSHA256` command acce",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-015",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does AVAP handle date and time operations?",
|
|
"answer_preview": "AVAP provides three commands to cover all possible conversions between time representations. These commands support calendar formats in Python's `strftime` notation and calculations with `TimeDelta` expressed in seconds (positive for adding, negative for subtracting).\n\nThe context also mentions that",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-016",
|
|
"category": "RETRIEVAL",
|
|
"question": "What is the AddvariableToJSON command and how is it used to build JSON objects?",
|
|
"answer_preview": "The `AddvariableToJSON` command in this context is used to add variables to a JSON object. Specifically, it takes two parameters: `clave`, which specifies the key for the variable, and `datos_cliente`, which contains the data that will be added as a value under the specified key.\n\nFor example:\n```pl",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-017",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does the getListLen command work and what is it used for?",
|
|
"answer_preview": "The getListLen command counts the number of elements in a list or string. It can be used to determine the length of any collection, such as a list of items or a string of characters.\n\nFor example:\n- The first command `getListLen(mi_lista, cantidad)` calculates the length of the list named `mi_lista`",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-018",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does the randomString command work in AVAP?",
|
|
"answer_preview": "The `randomString` command generates a string of characters based on the specified parameters. Here's how it works:\n\n- `[1] randomString(\"[A-Z]\\d\", 32, token_seguridad)`: This command generates a 32-character string consisting only of uppercase letters (A-Z) and digits (0-9). The output is assigned ",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-019",
|
|
"category": "RETRIEVAL",
|
|
"question": "What is the $ dereference operator in AVAP and when is it used?",
|
|
"answer_preview": "The $ dereference operator in AVAP indicates that the value of a variable should be extracted from the table of symbols. This operator is utilized by the native command `addVar(copia, $original)`, where `$` signifies that the original variable's value should be retrieved.\n\nIn this context, it seems ",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-R-020",
|
|
"category": "RETRIEVAL",
|
|
"question": "How does AVAP handle ORM database operations? What commands are available?",
|
|
"answer_preview": "AVAP provides several commands for handling ORM database operations, including:\n\n- **ormCheckTable(tableName, varTarget)**: Checks the existence of a table in the connected database.\n- **ormCreateTable(fields, fieldsType, tableName, varTarget)**: DDL command to create tables.\n- **ormAccessSelect(fie",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-001",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that reads a 'name' parameter and returns a personalized greeting.",
|
|
"answer_preview": "```avap\n/// personalizes a greeting based on the provided name\n\nfunction greet(name) {\n /// creates a personalized greeting message\n return \"Hello, \" + name + \"! How are you today?\";\n}\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-002",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that reads a 'password' parameter, generates a SHA-256 hash, and returns it.",
|
|
"answer_preview": "```avap\nreadParam(\"password\")\ngenerateSHA256Hash(password)\nreturn hashed_password\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-003",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that loops from 1 to 5, builds a JSON object with each index as a key, and returns it.",
|
|
"answer_preview": "```avap\nx = 10\ny = 20\n\n# Build the JSON object\njson_obj = {}\n\nfor i in range(1, 6):\n json_obj[i] = x + y\n\nreturn json_obj\n```\n\nThis script initializes two variables `x` and `y`, then builds a JSON object with each index from 1 to 5 as keys. The values are the sum of `x` and `y`.",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-004",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that validates if a 'role' parameter belongs to a list of allowed roles and returns the access result.",
|
|
"answer_preview": "```avap\n// Define the allowed roles as a list\nlet allowedRoles = [\"admin\", \"editor\", \"root\"];\n\n// Check if the provided role is in the allowed roles list\nif (allowedRoles.includes(rol)) {\n acceso = True;\n} else {\n acceso = False;\n}\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-005",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that makes a GET request to an external API and handles connection errors.",
|
|
"answer_preview": "```avap\ntry()\n // Make the GET request to the external API\n var res = httpGet(\"https://example.com/api/resource\", {}, \"GET\")\nexception(e)\n addVar(_status, 500)\n addResult(\"Error al conectar con la API externa.\")\nend()\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-006",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP function that takes two numbers and returns their sum, then call it and return the result.",
|
|
"answer_preview": "```plaintext\nfunction suma(a, b){\n total = a + b\n return(total)\n}\n\nresult = suma(5, 3)\nreturn(result)\n```\n\nThe `suma` function in AVAP adds two numbers together and returns their sum. When called with arguments `5` and `3`, it will return `8`.",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-007",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that reads a 'subtotal' parameter, computes 21% VAT, and returns the total.",
|
|
"answer_preview": "```avap\nfunction computeTotal(subtotal){\n iva = subtotal * 0.21\n total = subtotal + iva\n return(total)\n}\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-008",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that reads an 'api_key' parameter and returns status 403 if it is null.",
|
|
"answer_preview": "```avap\n/// checks for the presence of the api_key parameter\nif(api_key, None, \"==\")\n /// sets the status to 403\n addVar(_status, 403)\n /// sets an error message\n addVar(error, \"Acceso denegado: falta API KEY\")\nend()\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-009",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that generates a 32-character random alphanumeric token and returns it.",
|
|
"answer_preview": "```avap\ntoken = randomString(\"[A-Z]\\d\", 32, token_seguridad)\nreturn(token)\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-010",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that reads a 'lang' parameter and returns 'Hola' if it is 'es' or 'Hello' if it is 'en'.",
|
|
"answer_preview": "```avap\nif(l, \"es\", \"=\")\n addVar(msg, \"Hola\")\nend()\n\nif(l, \"en\", \"=\")\n addVar(msg, \"Hello\")\nend()\naddResult(msg)\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-011",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that checks if a database table exists and creates it if it does not.",
|
|
"answer_preview": "```avap\nvarTarget = ormCheckTable(\"my_database\", \"my_table\")\nif varTarget == 0:\n # Table does not exist, create it\n varTarget = ormCreateTable([\"column1\", \"column2\"], [\"type1\", \"type2\"], \"my_database.my_table\", varTarget)\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-012",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that gets the current UTC timestamp and adds 24 hours to compute an expiration time.",
|
|
"answer_preview": "```avap\ngetDateTime(\"\", 86400, \"UTC\", expira)\naddResult(expira)\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-013",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that receives a new password parameter, validates it is not equal to the old password, and returns a confirmation.",
|
|
"answer_preview": "```avap\nconfirmPassword(newPass: string) {\n if (newPass !== pass_antigua) {\n return \"Confirmation: Password change successful.\";\n } else {\n return \"Error: New password cannot be the same as the old one.\";\n }\n}\n```\n\nEvidence:\n- \"<exact quote from context>\"\n(only quotes you actu",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-014",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that reads a list parameter and returns its element count.",
|
|
"answer_preview": "```avap\n// 1. Obtain the length of the list\ngetListLen(myList, len)\n\n// 2. Return the element count\nlen\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-015",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that uses a validation function to check a token parameter and returns the authorization result.",
|
|
"answer_preview": "```avap\n// Validate the token using the es_valido function\nlet validatedToken = es_valido(\"SECRET\");\n\n// Check if the token is authorized\nif (validatedToken) {\n // Token is valid, proceed with further operations\n} else {\n // Token is not authorized, handle accordingly\n}\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-016",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that returns two values in the HTTP response: a status code 200 and a message 'Success'.",
|
|
"answer_preview": "```avap\naddVar(code, 200)\naddVar(status, \"Success\")\naddResult(code)\naddResult(status)\n\n// Additional function to return a message\nfunction es_valido(token){\n response = False\n if(token, \"SECRET\", \"=\")\n response = True\n end()\n return(response)\n}\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-017",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that reads a 'saldo' parameter and returns True if it is greater than zero, False otherwise.",
|
|
"answer_preview": "```avap\n/// checks if the saldo is greater than zero\nif(saldo, 0, \">\")\n permitir = True\nelse()\n permitir = False\nend()\n\npermitir\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-018",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that converts a Unix timestamp parameter to a human-readable date in dd/mm/yyyy format.",
|
|
"answer_preview": "```avap\nstampToDatetime(1708726162, \"%d/%m/%Y\", 0, fecha_human)\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-019",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that replaces all spaces in a string parameter with hyphens and returns the result.",
|
|
"answer_preview": "```avap\nreplace(\"spaces\", \" \", \"-\")\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-C-020",
|
|
"category": "CODE_GENERATION",
|
|
"question": "Write an AVAP script that uses try/exception to execute a raw SQL query and return status 500 on database errors.",
|
|
"answer_preview": "```avap\ntry()\n ormDirect(\"UPDATE table_inexistente SET a=1\", res)\nexception(e)\n addVar(_status, 500)\n addResult(\"Error de base de datos\")\nend\n```",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-001",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "Can you summarize what you just explained about AVAP scopes in fewer words?",
|
|
"answer_preview": "AVAP uses three types of scopes: Global Scope, Main Local Scope, and Function Scope. Variables are resolved from the closest to the farthest scope, with the Main Local Scope not visible within functions. If a variable isn't found in these scopes, it results in an execution error.",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-002",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "You mentioned that addResult builds the JSON response — can you clarify how multiple addResult calls work together?",
|
|
"answer_preview": "Certainly! The `addResult` function is responsible for constructing and adding variables to the final JSON response. Each call to `addResult(variable)` adds a new variable to the JSON structure.\n\nFor example, if you have two `addResult` calls:\n1. `addResult(hashed_password)`\n2. `addResult(secure_tok",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-003",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "What is the difference between addVar and a plain assignment like x = 10 in AVAP?",
|
|
"answer_preview": "In AVAP, `addVar` allows for direct variable assignment using the `=` operator, which provides flexibility while maintaining strict context control. This means that when you use `addVar(copia, $original)`, it assigns the value of `$original` to a variable named \"copia\". The key difference is that `a",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-004",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "Can you explain again the difference between the two modes of the if() command?",
|
|
"answer_preview": "The `if()` command in AVAP has two different modes for its invocations:\n\n1. **Modo 1 (Comparación estructurada):** This mode is used when comparing two simple values directly, such as variables or literals. The syntax is:\n ```avap\n if(átomo_1, átomo_2, \"operador\")\n ```\n - **Argumentos 1 y 2:",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-005",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "What happens if an error occurs in AVAP without a try block?",
|
|
"answer_preview": "If an error occurs in AVAP without a try block, the variable destination receives `None`. This is indicated by the comment: \"* **`RequestPost(url, querystring, headers, body, destino, timeout)`**: Ejecuta un POST almacenando la respuesta en `destino`. * Si se supera, la variable destino recibe `None",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-006",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "Can you explain again how the timeout in RequestGet works?",
|
|
"answer_preview": "The `timeout` parameter in the `RequestGet` function is used to control the maximum amount of time that the request will wait for a response before it cancels the operation and returns `None`. This helps prevent potential issues where the server might take longer than expected to respond, leading to",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-007",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "Can I iterate over a list of items in AVAP instead of a numeric range?",
|
|
"answer_preview": "Yes, you can iterate over a list of items in AVAP by using the `itemFromList` command. This allows you to access elements within the list without needing to know their indices beforehand.\n\nFor example:\n```avap\n// 1. Obtain the length of the list\ngetListLen(myList, len)\n\n// 2. Iterate with index-cont",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-008",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "What is the difference between RequestGet and RequestPost in practice?",
|
|
"answer_preview": "In practice, **RequestGet** and **RequestPost** are used to interact with a web service or API by sending HTTP requests. The main differences between them are:\n\n- **RequestGet**: This method sends an HTTP GET request without including any body content (such as JSON or form data). It is typically use",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-009",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "Goroutines cannot access Main Local Scope — can you give a practical example of why that matters?",
|
|
"answer_preview": "Certainly! The reason goroutines cannot directly access the `Main Local Scope` is crucial for managing resources and avoiding unintended side effects. Let's consider an example to illustrate this point:\n\n```python\nx = 10\ny = 20\n\n# This variable x is in the Main Local Scope, which means it can be acc",
|
|
"n_chunks": 5
|
|
},
|
|
{
|
|
"id": "GD-V-010",
|
|
"category": "CONVERSATIONAL",
|
|
"question": "What format does encodeSHA256 return its output in?",
|
|
"answer_preview": "The `encodeSHA256` function returns its output in the form of a hexadecimal digest. Specifically, it produces a 64-character hex-digest as specified by SHA-256. This ensures that the data is securely hashed and can be easily verified for integrity.",
|
|
"n_chunks": 5
|
|
}
|
|
]
|
|
}
|
|
} |