373 lines
24 KiB
JSON
373 lines
24 KiB
JSON
{
|
||
"generated_at": "2026-04-01T13:46:14.075064",
|
||
"embedding_model": "qwen3-0.6B-emb:latest",
|
||
"index_name": "avap-docs-test-v4",
|
||
"result": {
|
||
"status": "ok",
|
||
"questions_evaluated": 50,
|
||
"elapsed_seconds": 639.3,
|
||
"judge_model": "claude-sonnet-4-20250514",
|
||
"index": "avap-docs-test-v4",
|
||
"category_filter": "all",
|
||
"scores": {
|
||
"faithfulness": 0.5937,
|
||
"answer_relevancy": 0.8515,
|
||
"context_recall": 0.6521,
|
||
"context_precision": 0.6772
|
||
},
|
||
"global_score": 0.6936,
|
||
"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 a proprietary language that is specifically designed to facilitate the orchestration of secure, concurrent, and deterministic microservices and I/O operations. It is not intended as a general-purpose programming language but rather as a domain-specific lang",
|
||
"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 works by evaluating a logical or comparison expression. The structure of an `if()` statement is as follows:\n\n```plaintext\nif(expression, value1, operator)\n```\n\nHere's how it functions and closes blocks:\n\n- **Expression**: This evaluates to either a boolean (true",
|
||
"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 `RequestPost` and `RequestGet` commands. These commands allow for making POST and GET requests, respectively.\n\nTimeout management in AVAP involves a parameter called `timeout`. If this parameter exceeds its set value, it causes the destination variable to",
|
||
"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 defined using the `function` keyword followed by an identifier and parameters. The function body is enclosed within curly braces `{}`.\n\n- **Function Scope:** Variables declared within a function have a local scope that is limited to that function. They cannot be accessed or mo",
|
||
"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: Global Scope, Main Local Scope, and Function Scope. The visibility rules for these scopes are as follows:\n\n1. **Global Scope**: Variables declared at the top level or outside any function definition can be accessed from anywhere in the program.\n2. *",
|
||
"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 achieved through the use of goroutines, which are lightweight threads that can be created and managed within a single process. Goroutines allow for concurrent execution of tasks without requiring explicit thread management.\n\nGoroutines in AVAP are launched using the `go` keywo",
|
||
"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 in AVAP inspects incoming HTTP requests in a hierarchical order: first from the URL (Query arguments), then within the JSON body, and finally through the form data. If the requested parameter does not exist, the variable destination is initialized as `None`.\n\nFor example:\n```a",
|
||
"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 in AVAP are used to define loops that iterate over a sequence of indices. Here's how they function:\n\n1. **Defining the Loop:**\n - The loop is defined using the `startLoop(contador, inicio, fin)` syntax.\n - This starts the iteration process based on numeri",
|
||
"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 registers variables that will form part of the final JSON body of the HTTP response. It takes a variable as an argument, which indicates what data should be included in the response.\n\nIn the provided example:\n\n```plaintext\nresult = \"Hello,\" + name \naddResult(result)\n```\n\nHere",
|
||
"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()` block to catch exceptions. The `exception()` command within a `try`-`except` structure allows you to handle specific exceptions by assigning them to variables.\n\nHere's how it works:\n\n1. **Try Block**: You place your code inside a `try` block.\n2. *",
|
||
"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 not explicitly mentioned in the provided context. However, based on the information given about other commands like `registerEndpoint`, `addVar`, and `system_command`, we can infer that a similar functionality might be available for replacing values or strings with",
|
||
"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": "The following keywords in AVAP are reserved and cannot be used as identifiers:\n\n- _status\n\nThese keywords have special meanings within the language and should not be used as variable names or other identifier types.",
|
||
"n_chunks": 5
|
||
},
|
||
{
|
||
"id": "GD-R-013",
|
||
"category": "RETRIEVAL",
|
||
"question": "How does AVAP handle string formatting and concatenation?",
|
||
"answer_preview": "AVAP handles string formatting and concatenation through the use of escape sequences within strings. Specifically, it supports the following escape sequences:\n\n- `\\\\` for a backslash character.\n- `\\n` for a newline.\n- `\\t` for a tab.\n- `\\r` for a carriage return.\n- `\\'` for an apostrophe.\n\nFor examp",
|
||
"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 hash a payload data string using the SHA-256 algorithm. This produces a 64-character hexadecimal digest that serves as an irreversible representation of the original input, enhancing security for storing passwords or verifying data integrity.\n\nHere's how",
|
||
"n_chunks": 5
|
||
},
|
||
{
|
||
"id": "GD-R-015",
|
||
"category": "RETRIEVAL",
|
||
"question": "How does AVAP handle date and time operations?",
|
||
"answer_preview": "AVAP provides several commands for handling dates and times:\n\n1. **getDateTime(formato, timedelta, zona_horaria, destino)**: Captures the current system date and time, applies the specified `timedelta`, and converts it to the given `zona_horaria` before storing the result.\n\n2. **stampToDatetime(epoc",
|
||
"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 AVAP is used to dynamically inject a new property into an existing JSON object. This allows for modifying or adding properties to a JSON structure without needing to parse or construct the entire JSON string from scratch.\n\nHere's how it works:\n\n1. **Syntax**: The c",
|
||
"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 works by taking a list as an argument and returning its length. It iterates through each element of the list, counting them up until it reaches the end of the list.\n\nHere's how it typically functions:\n\n1. The function takes one parameter: `mi_lista`, which is expected to be ",
|
||
"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 randomly generated string of characters based on the provided pattern and length. The resulting string is then stored in the specified destination.\n\nHere's how it works:\n\n1. **Pattern**: A regular expression (regex) pattern defines which characters are allowed ",
|
||
"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 variable named \"original\" should be looked up in the symbol table. This allows for dynamic access to variables, enabling a more flexible syntax compared to static assignment.\n\nIn AVAP, the `$` prefix on an identifier refers to the value of anot",
|
||
"n_chunks": 5
|
||
},
|
||
{
|
||
"id": "GD-R-020",
|
||
"category": "RETRIEVAL",
|
||
"question": "How does AVAP handle ORM database operations? What commands are available?",
|
||
"answer_preview": "AVAP handles ORM (Object-Relational Mapping) database operations through the `ormCheckTable`, `ormCreateTable`, `ormAccessSelect`, `ormInsert`, and `ormUpdate` commands. These commands allow for interacting with a specific table in the connected database, retrieving data using `ormAccessSelect`, ins",
|
||
"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\naddVar(name, \"Alberto\")\nresult = \"Hello,\" + name \naddResult(result)\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\naddParam(password, pass_nueva)\npass_antigua = \"password\"\nif(pass_nueva, pass_antigua, \"!=\"):\n addVar(cambio, \"Contraseña actualizada\")\nend()\naddResult(cambio)\n\n# Generate SHA-256 hash of the password parameter\nhash_result = encodeSHA256(password, \"result\")\n\n# Return the generated hash\nadd",
|
||
"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\nstartLoop(i, 1, 6)\n variableFromJSON(\"key_%s\" % i, \"value_%s\" % i, mi_json_object)\nendLoop()\naddResult(mi_json_object)\n```",
|
||
"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\nif(r, [\"admin\", \"editor\", \"root\"], \"in\")\n acceso = True\nend()\naddResult(acceso)\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\nRequestGet(\"https://api.example.com/data\", 0, 0, respuesta)\n```\n\nThis script sends a GET request to the specified URL using the `RequestGet` method from AVAP. It includes error handling for potential connection issues by checking the `_status` variable after the request is made. If an error ",
|
||
"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": "```avap\nfunction suma(a, b) {\n total = a + b;\n return(total);\n}\nresultado = suma(10, 20);\naddResult(resultado);\n```\n\nThe `suma` function takes two numbers as input parameters (`a` and `b`) and returns their sum. When called with the arguments `10` and `20`, it will return `30`.",
|
||
"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\nsubtotal = readParam(\"subtotal\")\niva = subtotal * 0.21\ntotal = subtotal + iva\nreturn(total)\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\naddParam(\"api_key\", \"key\")\nif(key, None, \"==\")\n addVar(_status, 403)\n addVar(error, \"Acceso denegado: falta API KEY\")\n addResult(error)\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\nrandomString(\"[A-Z]\\d\", 32, \"token_seguridad\")\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\naddParam(\"lang\", \"l\")\nif(l, \"es\", \"=\")\n addVar(msg, \"Hola\")\nend()\nelse\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\normCheckTable(\"my_table\", \"my_database\")\nif(resultado_comprobacion, False, '==')\n ormCreateTable(\"fields\", \"fieldsType\", \"my_database\", resultado_creacion)\nend()\naddResult(resultado_comprobacion)\naddResult(resultado_creacion)\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\npass_antigua = \"password\"\nif(pass_nueva != pass_antigua):\n addVar(cambio, \"Contraseña actualizada\")\nend()\naddResult(cambio)\n```",
|
||
"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. Iterate with index controlled\ni = 0\nwhile (i < len) {\n itemFromList(myList, i, currentItem)\n // ... process currentItem ...\n i = i + 1\n}\n\n// Return the element count\naddResult(len)\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\nfunction es_valido(token) {\n response = False\n if (token == \"SECRET\") \n response = True\n return(response)\n}\n\nautorizado = es_valido(\"SECRET\")\naddResult(autorizado)\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_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\nif(sal_par > 0)\n permitir = True\nelse()\n permitir = False\nend()\naddResult(permitir)\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)\naddResult(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\nreplaceSpacesWithHyphens(inputString)\n{\n let output = \"\";\n for (let i = 0; i < inputString.length; i++) {\n if (inputString[i] === \" \") {\n output += \"-\";\n } else {\n output += inputString[i];\n }\n }\n return output;\n}\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);\n addVar(_status, 500);\n addResult(\"Error de base de datos\");\n} catch(e) {\n addVar(status, \"Error en la consulta SQL\");\n}\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. The Main Local Scope is not visible within functions. If a variable isn't found in the visible 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 collecting variables into the final JSON body of the response. When called, it adds a variable to the list of results being built.\n\nFor example, consider this scenario:\n\n```plaintext\nfunction suma(a, b){\n total = a + b\n return(total)\n}\nres",
|
||
"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 dynamic variable assignment with the use of the `$` operator. When you write `addVar(copia, $original)`, it means that the value of the variable named \"original\" is being retrieved from the symbol table and assigned to the variable \"copia\". This provides flexibility in t",
|
||
"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": "Certainly! The `if()` command in AVAP has two distinct modes for its invocations:\n\n1. **Modo 1 (Comparación Estructurada):** This mode is used to compare two simple values directly, such as variables or literals. It requires that the first two arguments are either identifiers (variables) or literal ",
|
||
"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 but there is no `try` block present, the program will not handle or catch the exception. The execution of the code will continue as normal until it reaches the point where the exception was thrown. At that point, the system will typically throw a generic error message indi",
|
||
"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 handle situations where a request might take longer than expected due to network latency. If the request exceeds the specified timeout, the variable `destino` receives the value `None`.\n\nThis mechanism ensures that if there's an issue w",
|
||
"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": "In AVAP, you can iterate over a list or collection by using the `foreach` statement. This allows you to loop through each item in an array or any other iterable object.\n\nHere's how you might do it:\n\n```avap\nvar items = [\"apple\", \"banana\", \"cherry\"];\nforeach(item in items) {\n print(\"The current it",
|
||
"n_chunks": 5
|
||
},
|
||
{
|
||
"id": "GD-V-008",
|
||
"category": "CONVERSATIONAL",
|
||
"question": "What is the difference between RequestGet and RequestPost in practice?",
|
||
"answer_preview": "In practice, `RequestPost` and `RequestGet` are used to interact with a web service or API endpoint. The main differences between them are:\n\n- **POST Method**: When using `RequestPost`, you send data as part of the URL query parameters (querystring). This is typically used for submitting forms or se",
|
||
"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 due to the strict scope rules in AVAP. Here’s a practical example:\n\n```python\n# Example function with global and local variables\n\ndef main():\n x = 10 # Global variable visible from anywhere\n y = 20 # Local var",
|
||
"n_chunks": 5
|
||
},
|
||
{
|
||
"id": "GD-V-010",
|
||
"category": "CONVERSATIONAL",
|
||
"question": "What format does encodeSHA256 return its output in?",
|
||
"answer_preview": "encodeSHA256 returns its output in a hexadecimal string of 64 characters.",
|
||
"n_chunks": 5
|
||
}
|
||
]
|
||
}
|
||
} |