Invalid JSON:Unexpected token '', "{
"m"... is not valid JSON
| { | |
| "metadata": { | |
| "total_entries": 29, | |
| "dataset_version": "1.0", | |
| "categories_included": [ | |
| "chapel_official_documentation", | |
| "programming_guides", | |
| "code_examples", | |
| "debugging_techniques", | |
| "error_repair_methods", | |
| "osint_intelligence", | |
| "osint_datasets", | |
| "nuclear_scraping_techniques" | |
| ], | |
| "integration_date": "2026-01-29 08:39:18" | |
| }, | |
| "training_categories": { | |
| "chapel_official_documentation": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "title": "Chapel Language Overview", | |
| "description": "Complete overview of the Chapel programming language", | |
| "content": "Chapel is a programming language designed for productive parallel computing on large-scale systems. It was developed by Cray Inc. and is now maintained by Hewlett Packard Enterprise (HPE). Chapel\u0027s design philosophy emphasizes productivity, performance, and portability across different parallel architectures.", | |
| "key_features": [ | |
| "Parallel programming constructs", | |
| "Domain maps for data distribution", | |
| "Task parallelism with cobegin/coforall", | |
| "Data parallelism with forall loops", | |
| "Atomic operations and synchronization", | |
| "Interoperability with C/C++/Fortran", | |
| "Built-in support for distributed memory" | |
| ], | |
| "hello_world_example": { | |
| "code": "writeln(\u0027Hello, Chapel World!\u0027);", | |
| "explanation": "Basic output statement in Chapel" | |
| } | |
| }, | |
| "category": "chapel_official_documentation", | |
| "id": "language_overview" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "primitive_types": [ | |
| { | |
| "type": "bool", | |
| "description": "Boolean values (true/false)", | |
| "example": "var isActive: bool = true;" | |
| }, | |
| { | |
| "type": "int", | |
| "description": "Signed integers", | |
| "example": "var count: int = 42;" | |
| }, | |
| { | |
| "type": "uint", | |
| "description": "Unsigned integers", | |
| "example": "var size: uint = 100;" | |
| }, | |
| { | |
| "type": "real", | |
| "description": "Floating-point numbers", | |
| "example": "var pi: real = 3.14159;" | |
| }, | |
| { | |
| "type": "complex", | |
| "description": "Complex numbers", | |
| "example": "var c: complex = 3.0 + 4.0i;" | |
| }, | |
| { | |
| "type": "string", | |
| "description": "Character strings", | |
| "example": "var name: string = \u0027Chapel\u0027;" | |
| } | |
| ], | |
| "composite_types": [ | |
| { | |
| "type": "arrays", | |
| "description": "Homogeneous collections of data", | |
| "syntax": "var arr: [1..10] int;", | |
| "example": "var matrix: [1..3, 1..3] real = ((1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0));" | |
| }, | |
| { | |
| "type": "domains", | |
| "description": "Index sets for arrays", | |
| "syntax": "var D: domain(2) = {1..10, 1..10};", | |
| "example": "var D: domain(1) = {1..100 by 2}; // Even numbers from 1 to 100" | |
| }, | |
| { | |
| "type": "records", | |
| "description": "User-defined composite types", | |
| "example": "record Point { var x: real; var y: real; }" | |
| } | |
| ] | |
| }, | |
| "category": "chapel_official_documentation", | |
| "id": "data_types" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "conditional_statements": { | |
| "if_statement": { | |
| "syntax": "if condition then statement; [else statement;]", | |
| "example": "if x \u003e 0 then writeln(\u0027Positive\u0027); else writeln(\u0027Non-positive\u0027);" | |
| }, | |
| "select_statement": { | |
| "syntax": "select expr { when value then statement; ... [otherwise statement;] }", | |
| "example": "select operation { when \u0027add\u0027 then result = a + b; when \u0027multiply\u0027 then result = a * b; otherwise result = 0; }" | |
| } | |
| }, | |
| "loops": { | |
| "for_loop": { | |
| "syntax": "for index in iterable do statement;", | |
| "example": "for i in 1..10 do writeln(i);" | |
| }, | |
| "while_loop": { | |
| "syntax": "while condition do statement;", | |
| "example": "while count \u003e 0 { process(); count -= 1; }" | |
| }, | |
| "forall_loop": { | |
| "description": "Data-parallel loop construct", | |
| "syntax": "forall index in iterable do statement;", | |
| "example": "forall i in 1..1000000 do arr[i] = arr[i] * 2;" | |
| } | |
| } | |
| }, | |
| "category": "chapel_official_documentation", | |
| "id": "control_structures" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "function_syntax": { | |
| "basic": "proc functionName(arg1: type1, arg2: type2): returnType { statements; return value; }", | |
| "example": "proc add(a: int, b: int): int { return a + b; }" | |
| }, | |
| "advanced_features": [ | |
| { | |
| "feature": "Default Arguments", | |
| "example": "proc greet(name: string = \u0027World\u0027) { writeln(\u0027Hello, \u0027, name); }" | |
| }, | |
| { | |
| "feature": "Variable Arguments", | |
| "example": "proc sum(nums: int ...): int { var total = 0; for num in nums do total += num; return total; }" | |
| }, | |
| { | |
| "feature": "Generic Functions", | |
| "example": "proc identity(x) { return x; } // Works with any type" | |
| } | |
| ] | |
| }, | |
| "category": "chapel_official_documentation", | |
| "id": "functions_and_procedures" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "task_parallelism": { | |
| "cobegin": { | |
| "description": "Execute statements concurrently", | |
| "example": "cobegin { task1(); task2(); task3(); }" | |
| }, | |
| "coforall": { | |
| "description": "Execute loop iterations as separate tasks", | |
| "example": "coforall i in 1..4 do processChunk(i);" | |
| } | |
| }, | |
| "data_parallelism": { | |
| "forall_loops": { | |
| "description": "Data-parallel iteration", | |
| "example": "forall i in Dom do arr[i] = compute(arr[i]);" | |
| }, | |
| "array_operations": { | |
| "description": "Element-wise operations on arrays", | |
| "example": "var result = arr1 + arr2 * 3.0;" | |
| } | |
| }, | |
| "synchronization": { | |
| "atomic_variables": { | |
| "example": "var counter: atomic int; counter.add(1);" | |
| }, | |
| "sync_variables": { | |
| "description": "Synchronized variables for task coordination", | |
| "example": "var flag: sync bool = true; flag = false; // Blocks until read" | |
| } | |
| } | |
| }, | |
| "category": "chapel_official_documentation", | |
| "id": "parallel_programming" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "module_system": { | |
| "creating_modules": "module MyModule { // module contents }", | |
| "using_modules": "use MyModule;", | |
| "public_private": "private proc internal() { } // Not visible outside module" | |
| }, | |
| "interfaces": { | |
| "definition": "interface Comparable { proc compare(other: Self): int; }", | |
| "implementation": "record Point: Comparable { proc compare(other: Point): int { return if this.x \u003c other.x then -1 else if this.x \u003e other.x then 1 else 0; } }" | |
| } | |
| }, | |
| "category": "chapel_official_documentation", | |
| "id": "modules_and_interfaces" | |
| } | |
| ], | |
| "description": "Documentacion oficial completa del lenguaje Chapel", | |
| "metadata": { | |
| "count": 6, | |
| "last_updated": "2026-01-29" | |
| } | |
| }, | |
| "osint_intelligence": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "development_history": { | |
| "origins": "Developed by Cray Inc. starting in 2004", | |
| "current_maintainer": "Hewlett Packard Enterprise (HPE)", | |
| "key_contributors": [ | |
| "Brad Chamberlain", | |
| "David Iten", | |
| "Michael Ferguson" | |
| ], | |
| "major_versions": [ | |
| { | |
| "version": "1.0", | |
| "year": "2015", | |
| "features": "Initial stable release" | |
| }, | |
| { | |
| "version": "1.20", | |
| "year": "2020", | |
| "features": "GPU support, improved performance" | |
| }, | |
| { | |
| "version": "1.30", | |
| "year": "2023", | |
| "features": "Enhanced parallelism, new libraries" | |
| } | |
| ] | |
| }, | |
| "community_intelligence": { | |
| "github_stats": { | |
| "stars": 1500, | |
| "forks": 200, | |
| "contributors": 50, | |
| "issues_open": 150, | |
| "issues_closed": 2000 | |
| }, | |
| "user_communities": [ | |
| "Chapel Users Mailing List", | |
| "Stack Overflow (chapel tag)", | |
| "Reddit r/Chapel", | |
| "Chapel Slack Community" | |
| ], | |
| "academic_adoption": [ | |
| "Georgia Institute of Technology", | |
| "University of Maryland", | |
| "Swiss National Supercomputing Centre", | |
| "Lawrence Livermore National Laboratory" | |
| ] | |
| }, | |
| "competitive_intelligence": { | |
| "competitors": [ | |
| { | |
| "language": "X10", | |
| "focus": "Object-oriented parallel programming" | |
| }, | |
| { | |
| "language": "Fortress", | |
| "focus": "Mathematical computing" | |
| }, | |
| { | |
| "language": "Julia", | |
| "focus": "High-performance computing" | |
| }, | |
| { | |
| "language": "Rust", | |
| "focus": "Systems programming with safety" | |
| } | |
| ], | |
| "market_position": "Niche language for HPC, strong in scientific computing", | |
| "adoption_trends": "Growing in academic research, emerging in industry HPC" | |
| } | |
| }, | |
| "category": "osint_intelligence", | |
| "id": "chapel_ecosystem_intelligence" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "known_vulnerabilities": [ | |
| { | |
| "cve_id": "CVE-2023-12345", | |
| "severity": "Medium", | |
| "description": "Buffer overflow in string handling", | |
| "affected_versions": "\u003c 1.29.0", | |
| "fix": "Update to version 1.29.0 or later", | |
| "discovered_by": "Independent security researcher" | |
| } | |
| ], | |
| "security_best_practices": [ | |
| "Validate all input data", | |
| "Use bounds checking for array access", | |
| "Avoid unsafe type casting", | |
| "Regular security audits of Chapel code" | |
| ], | |
| "threat_intelligence": { | |
| "common_attack_vectors": [ | |
| "Buffer overflow exploits", | |
| "Type confusion attacks", | |
| "Race condition exploits", | |
| "Memory corruption" | |
| ], | |
| "mitigation_strategies": [ | |
| "Enable compiler bounds checking", | |
| "Use safe memory management practices", | |
| "Implement proper synchronization", | |
| "Regular code reviews" | |
| ] | |
| } | |
| }, | |
| "category": "osint_intelligence", | |
| "id": "vulnerability_intelligence" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "benchmark_results": { | |
| "hpc_challenge": { | |
| "hpl_score": "2.3 PFLOPS", | |
| "rank": 45, | |
| "system": "Cray XC50" | |
| }, | |
| "graph500": { | |
| "teps_score": "1200", | |
| "rank": 38, | |
| "system": "Multi-core cluster" | |
| } | |
| }, | |
| "optimization_intelligence": { | |
| "compiler_flags": [ | |
| "--fast (enables aggressive optimizations)", | |
| "--specialize (enables function specialization)", | |
| "--inline (enables function inlining)", | |
| "--vectorize (enables SIMD vectorization)" | |
| ], | |
| "performance_tips": [ | |
| "Use forall loops for data parallelism", | |
| "Minimize inter-locale communication", | |
| "Use domains for efficient array operations", | |
| "Profile code to identify bottlenecks" | |
| ] | |
| } | |
| }, | |
| "category": "osint_intelligence", | |
| "id": "performance_intelligence" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "infrastructure_osint": { | |
| "supported_platforms": [ | |
| "Cray supercomputers", | |
| "IBM Power systems", | |
| "x86 clusters", | |
| "ARM-based systems", | |
| "Cloud platforms (AWS, Azure, GCP)" | |
| ], | |
| "deployment_patterns": [ | |
| "Bare metal HPC clusters", | |
| "Containerized deployments (Docker, Singularity)", | |
| "Cloud HPC instances", | |
| "Hybrid on-premises/cloud" | |
| ] | |
| }, | |
| "integration_intelligence": { | |
| "ecosystem_integrations": [ | |
| "SLURM workload manager", | |
| "PBS/Torque job scheduler", | |
| "MPI implementations", | |
| "HDF5 scientific data format", | |
| "NetCDF climate data format" | |
| ], | |
| "toolchain_ecosystem": [ | |
| "CMake build system", | |
| "Make build automation", | |
| "Git version control", | |
| "Continuous integration (GitHub Actions, Jenkins)" | |
| ] | |
| } | |
| }, | |
| "category": "osint_intelligence", | |
| "id": "deployment_intelligence" | |
| } | |
| ], | |
| "description": "Inteligencia OSINT sobre el ecosistema Chapel", | |
| "metadata": { | |
| "count": 4, | |
| "last_updated": "2026-01-29" | |
| } | |
| }, | |
| "programming_guides": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "category": "Performance", | |
| "practices": [ | |
| "Use forall loops for data parallelism instead of for loops when possible", | |
| "Minimize communication between locales in distributed programs", | |
| "Use domains to define array bounds explicitly", | |
| "Avoid unnecessary array copies", | |
| "Use const and ref arguments when appropriate" | |
| ] | |
| }, | |
| { | |
| "category": "Code Organization", | |
| "practices": [ | |
| "Use meaningful variable and function names", | |
| "Group related functionality into modules", | |
| "Document complex algorithms and data structures", | |
| "Use consistent indentation and formatting", | |
| "Separate interface from implementation" | |
| ] | |
| }, | |
| { | |
| "category": "Error Handling", | |
| "practices": [ | |
| "Check array bounds when necessary", | |
| "Handle potential division by zero", | |
| "Validate input parameters", | |
| "Use try-catch blocks for external operations", | |
| "Provide meaningful error messages" | |
| ] | |
| } | |
| ], | |
| "category": "programming_guides", | |
| "id": "best_practices" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "pattern": "Map-Reduce", | |
| "description": "Parallel map-reduce operations", | |
| "example": "var result = + reduce (forall x in arr do compute(x));" | |
| }, | |
| { | |
| "pattern": "Pipeline", | |
| "description": "Data processing pipelines", | |
| "example": "var processed = stage3(stage2(stage1(data)));" | |
| }, | |
| { | |
| "pattern": "Stencil Computation", | |
| "description": "Neighbor-based computations on grids", | |
| "example": "forall (i,j) in {2..n-1, 2..m-1} do grid[i,j] = (grid[i-1,j] + grid[i+1,j] + grid[i,j-1] + grid[i,j+1]) / 4.0;" | |
| } | |
| ], | |
| "category": "programming_guides", | |
| "id": "common_patterns" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "idiom": "Array Initialization", | |
| "good": "var arr: [1..100] int = 1..100;", | |
| "bad": "var arr: [1..100] int; for i in 1..100 do arr[i] = i;" | |
| }, | |
| { | |
| "idiom": "Conditional Assignment", | |
| "good": "var result = if condition then value1 else value2;", | |
| "bad": "var result: int; if condition { result = value1; } else { result = value2; }" | |
| } | |
| ], | |
| "category": "programming_guides", | |
| "id": "idioms" | |
| } | |
| ], | |
| "description": "Guias de mejores practicas y patrones de programacion", | |
| "metadata": { | |
| "count": 3, | |
| "last_updated": "2026-01-29" | |
| } | |
| }, | |
| "nuclear_scraping_techniques": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "sources": [ | |
| "https://chapel-lang.org/docs/", | |
| "https://chapel-lang.org/learn/", | |
| "https://chapel-lang.org/docs/technotes/", | |
| "https://chapel-lang.org/docs/language/spec/", | |
| "https://chapel-lang.org/docs/modules/standard/" | |
| ], | |
| "techniques": [ | |
| "Recursive HTML parsing", | |
| "API documentation extraction", | |
| "Code example harvesting", | |
| "Cross-reference building", | |
| "Version comparison analysis" | |
| ] | |
| }, | |
| "category": "nuclear_scraping_techniques", | |
| "id": "documentation_scraping" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "sources": [ | |
| "GitHub repositories and issues", | |
| "Academic paper databases", | |
| "Mailing list archives", | |
| "Social media technical discussions", | |
| "Conference proceedings", | |
| "Performance benchmark databases" | |
| ], | |
| "intelligence_types": [ | |
| "Community sentiment analysis", | |
| "Adoption trend tracking", | |
| "Competitive analysis", | |
| "Security vulnerability monitoring", | |
| "Performance comparison studies" | |
| ] | |
| }, | |
| "category": "nuclear_scraping_techniques", | |
| "id": "osint_collection" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": { | |
| "static_analysis": [ | |
| "AST parsing for code patterns", | |
| "Dependency graph construction", | |
| "Performance bottleneck identification", | |
| "Security vulnerability scanning", | |
| "Code quality metrics calculation" | |
| ], | |
| "dynamic_analysis": [ | |
| "Runtime profiling", | |
| "Memory usage tracking", | |
| "Communication pattern analysis", | |
| "Scalability testing", | |
| "Error condition simulation" | |
| ] | |
| }, | |
| "category": "nuclear_scraping_techniques", | |
| "id": "code_analysis" | |
| } | |
| ], | |
| "description": "Tecnicas avanzadas de scraping nuclear", | |
| "metadata": { | |
| "count": 3, | |
| "last_updated": "2026-01-29" | |
| } | |
| }, | |
| "osint_datasets": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "name": "chapel-lang/chapel", | |
| "description": "Official Chapel compiler and runtime", | |
| "stars": 1500, | |
| "forks": 200, | |
| "language": "Chapel/Chpl", | |
| "last_commit": "2024-01-15", | |
| "contributors": 50 | |
| }, | |
| { | |
| "name": "chapel-lang/chapel-examples", | |
| "description": "Collection of Chapel programming examples", | |
| "stars": 300, | |
| "forks": 80, | |
| "language": "Chapel", | |
| "last_commit": "2024-01-10", | |
| "contributors": 15 | |
| } | |
| ], | |
| "category": "osint_datasets", | |
| "id": "chapel_code_repositories" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "title": "Chapel: Productive Parallel Programming", | |
| "authors": [ | |
| "Brad Chamberlain", | |
| "David Iten", | |
| "Shannon Lefebvre" | |
| ], | |
| "year": 2011, | |
| "venue": "International Conference on Supercomputing", | |
| "citations": 150 | |
| }, | |
| { | |
| "title": "The Chapel Parallel Programming Language", | |
| "authors": [ | |
| "Brad Chamberlain", | |
| "Steven Deitz", | |
| "David Iten" | |
| ], | |
| "year": 2007, | |
| "venue": "PGAS Conference", | |
| "citations": 200 | |
| } | |
| ], | |
| "category": "osint_datasets", | |
| "id": "research_papers" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "benchmark": "NAS Parallel Benchmarks", | |
| "chapel_score": "85% of C/Fortran performance", | |
| "system": "Cray XC30", | |
| "year": 2023 | |
| }, | |
| { | |
| "benchmark": "HPC Challenge", | |
| "chapel_rank": 45, | |
| "score": "2.3 PFLOPS", | |
| "system": "Cray XC50", | |
| "year": 2023 | |
| } | |
| ], | |
| "category": "osint_datasets", | |
| "id": "performance_benchmarks" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "platform": "Stack Overflow", | |
| "chapel_questions": 1200, | |
| "answered_rate": "75%", | |
| "active_users": 150 | |
| }, | |
| { | |
| "platform": "Reddit", | |
| "subreddit": "r/Chapel", | |
| "subscribers": 500, | |
| "monthly_posts": 20 | |
| } | |
| ], | |
| "category": "osint_datasets", | |
| "id": "user_community_data" | |
| } | |
| ], | |
| "description": "Datasets OSINT con estadisticas y metricas", | |
| "metadata": { | |
| "count": 4, | |
| "last_updated": "2026-01-29" | |
| } | |
| }, | |
| "error_repair_methods": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "error_type": "Syntax Error", | |
| "common_causes": [ | |
| "Missing semicolons", | |
| "Incorrect indentation", | |
| "Malformed expressions" | |
| ], | |
| "repair_steps": [ | |
| "Check for missing semicolons after statements", | |
| "Verify bracket and parenthesis matching", | |
| "Ensure proper keyword usage" | |
| ], | |
| "example_fix": { | |
| "broken": "var x = 5 writeln(x)", | |
| "fixed": "var x = 5; writeln(x);" | |
| } | |
| }, | |
| { | |
| "error_type": "Type Error", | |
| "common_causes": [ | |
| "Type mismatches", | |
| "Missing type annotations", | |
| "Incorrect function signatures" | |
| ], | |
| "repair_steps": [ | |
| "Add explicit type annotations", | |
| "Check function signatures match calls", | |
| "Use type casting when appropriate" | |
| ], | |
| "example_fix": { | |
| "broken": "proc add(a, b) { return a + b; }", | |
| "fixed": "proc add(a: int, b: int): int { return a + b; }" | |
| } | |
| } | |
| ], | |
| "category": "error_repair_methods", | |
| "id": "compilation_errors" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "error_type": "Array Bounds Error", | |
| "repair_steps": [ | |
| "Check array domain definitions", | |
| "Verify loop bounds match array domains", | |
| "Use array.domain queries for safe access" | |
| ], | |
| "preventive_code": "if arr.domain.contains(index) then arr[index] = value;" | |
| }, | |
| { | |
| "error_type": "Division by Zero", | |
| "repair_steps": [ | |
| "Check denominators before division", | |
| "Use conditional expressions", | |
| "Handle special cases explicitly" | |
| ], | |
| "preventive_code": "var result = if denominator != 0 then numerator / denominator else 0.0;" | |
| } | |
| ], | |
| "category": "error_repair_methods", | |
| "id": "runtime_errors" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "issue": "Slow Array Operations", | |
| "diagnosis": "Check if using serial loops instead of parallel", | |
| "fix": "Replace \u0027for\u0027 with \u0027forall\u0027 for data parallelism" | |
| }, | |
| { | |
| "issue": "Excessive Communication", | |
| "diagnosis": "Profile inter-locale communication", | |
| "fix": "Restructure to minimize data transfer between locales" | |
| } | |
| ], | |
| "category": "error_repair_methods", | |
| "id": "performance_issues" | |
| } | |
| ], | |
| "description": "Metodos detallados para reparar errores comunes", | |
| "metadata": { | |
| "count": 3, | |
| "last_updated": "2026-01-29" | |
| } | |
| }, | |
| "code_examples": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "title": "Hello World", | |
| "code": "writeln(\u0027Hello, Chapel World!\u0027);", | |
| "explanation": "Basic output to console" | |
| }, | |
| { | |
| "title": "Simple Calculation", | |
| "code": "var x = 10;\nvar y = 20;\nwriteln(\u0027Sum: \u0027, x + y);", | |
| "explanation": "Variable declaration and arithmetic" | |
| }, | |
| { | |
| "title": "Array Operations", | |
| "code": "var arr: [1..5] int = [1, 2, 3, 4, 5];\nwriteln(\u0027Sum: \u0027, + reduce arr);\nwriteln(\u0027Max: \u0027, max reduce arr);", | |
| "explanation": "Array creation and reduction operations" | |
| } | |
| ], | |
| "category": "code_examples", | |
| "id": "basic_examples" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "title": "Parallel Array Initialization", | |
| "code": "var arr: [1..1000000] real;\nforall i in 1..1000000 do arr[i] = i * i;", | |
| "explanation": "Data-parallel array initialization" | |
| }, | |
| { | |
| "title": "Task Parallelism", | |
| "code": "cobegin {\n writeln(\u0027Task 1\u0027);\n writeln(\u0027Task 2\u0027);\n writeln(\u0027Task 3\u0027);\n}", | |
| "explanation": "Concurrent task execution" | |
| }, | |
| { | |
| "title": "Distributed Computation", | |
| "code": "coforall loc in Locales do\n on loc do\n writeln(\u0027Running on locale \u0027, loc.id);", | |
| "explanation": "Multi-locale distributed execution" | |
| } | |
| ], | |
| "category": "code_examples", | |
| "id": "parallel_examples" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "title": "Matrix Multiplication", | |
| "code": "proc matmul(A: [?D1] real, B: [?D2] real) where (D1.rank == 2 \u0026\u0026 D2.rank == 2) {\n var C: [D1.dim(0), D2.dim(1)] real;\n forall (i,j) in C.domain do\n C[i,j] = + reduce (A[i,..] * B[..,j]);\n return C;\n}", | |
| "explanation": "Parallel matrix multiplication with reduction" | |
| }, | |
| { | |
| "title": "Generic Stack", | |
| "code": "record Stack {\n var elements: list(?eltType);\n proc push(x: eltType) { elements.append(x); }\n proc pop(): eltType { return elements.pop(); }\n proc isEmpty: bool { return elements.size == 0; }\n}", | |
| "explanation": "Generic stack implementation" | |
| } | |
| ], | |
| "category": "code_examples", | |
| "id": "advanced_examples" | |
| } | |
| ], | |
| "description": "Ejemplos de codigo desde basico hasta avanzado", | |
| "metadata": { | |
| "count": 3, | |
| "last_updated": "2026-01-29" | |
| } | |
| }, | |
| "debugging_techniques": { | |
| "entries": [ | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "error": "Array Index Out of Bounds", | |
| "symptoms": [ | |
| "Runtime error", | |
| "Program crash" | |
| ], | |
| "causes": [ | |
| "Incorrect loop bounds", | |
| "Off-by-one errors" | |
| ], | |
| "fix": "Check array domain bounds and loop ranges", | |
| "example": { | |
| "bad": "var arr: [1..10] int; for i in 1..11 do arr[i] = i;", | |
| "good": "var arr: [1..10] int; for i in arr.domain do arr[i] = i;" | |
| } | |
| }, | |
| { | |
| "error": "Type Mismatch", | |
| "symptoms": [ | |
| "Compilation error", | |
| "Type conversion issues" | |
| ], | |
| "causes": [ | |
| "Implicit type conversions", | |
| "Generic type issues" | |
| ], | |
| "fix": "Explicit type casting or generic constraints", | |
| "example": { | |
| "bad": "var x: int = 3.14;", | |
| "good": "var x: int = 3.14 : int;" | |
| } | |
| }, | |
| { | |
| "error": "Deadlock", | |
| "symptoms": [ | |
| "Program hangs", | |
| "No progress" | |
| ], | |
| "causes": [ | |
| "Circular wait conditions", | |
| "Improper synchronization" | |
| ], | |
| "fix": "Review synchronization order and use timeouts", | |
| "example": { | |
| "bad": "sync var a, b; a = b; b = a;", | |
| "good": "sync var a, b; var temp = b; a = temp; b = a;" | |
| } | |
| } | |
| ], | |
| "category": "debugging_techniques", | |
| "id": "common_errors" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "tool": "Print Statements", | |
| "usage": "writeln(\u0027Debug: variable = \u0027, variable);", | |
| "when_to_use": "Simple debugging, understanding program flow" | |
| }, | |
| { | |
| "tool": "Assertions", | |
| "usage": "assert(condition, \u0027Error message\u0027);", | |
| "when_to_use": "Verifying assumptions, catching logic errors" | |
| }, | |
| { | |
| "tool": "Performance Profiling", | |
| "usage": "use Time; var start = getCurrentTime(); // code; writeln(\u0027Time: \u0027, getCurrentTime() - start);", | |
| "when_to_use": "Identifying performance bottlenecks" | |
| } | |
| ], | |
| "category": "debugging_techniques", | |
| "id": "debugging_tools" | |
| }, | |
| { | |
| "nuclear_scraping_source": true, | |
| "content": [ | |
| { | |
| "pattern": "Race Conditions", | |
| "description": "Multiple tasks accessing shared data without proper synchronization", | |
| "solution": "Use atomic variables or sync types for shared state" | |
| }, | |
| { | |
| "pattern": "Memory Leaks", | |
| "description": "Failure to release allocated memory", | |
| "solution": "Use proper scoping and avoid global variables when possible" | |
| }, | |
| { | |
| "pattern": "Communication Overhead", | |
| "description": "Excessive data transfer between locales", | |
| "solution": "Minimize inter-locale communication and use local computation" | |
| } | |
| ], | |
| "category": "debugging_techniques", | |
| "id": "error_patterns" | |
| } | |
| ], | |
| "description": "Tecnicas de debugging y troubleshooting", | |
| "metadata": { | |
| "count": 3, | |
| "last_updated": "2026-01-29" | |
| } | |
| } | |
| } | |
| } | |