diff --git a/config-gen.toml b/config-gen.toml new file mode 100644 index 0000000..57e9959 --- /dev/null +++ b/config-gen.toml @@ -0,0 +1,11 @@ +[params] + [params.submoduleLinks] + [params.submoduleLinks.aoc2020] + url = "https://dev.danilafe.com/Advent-of-Code/AdventOfCode-2020/src/commit/7a8503c3fe1aa7e624e4d8672aa9b56d24b4ba82" + path = "aoc-2020" + [params.submoduleLinks.blogstaticflake] + url = "https://dev.danilafe.com/Nix-Configs/blog-static-flake/src/commit/67b47d9c298e7476c2ca211aac5c5fd961637b7b" + path = "blog-static-flake" + [params.submoduleLinks.serverconfig] + url = "https://dev.danilafe.com/Nix-Configs/server-config/src/commit/98cffe09546aee1678f7baebdea5eb5fef288935" + path = "server-config" diff --git a/static/graph/graph.gen.js b/static/graph/graph.gen.js new file mode 100644 index 0000000..8e3e1a7 --- /dev/null +++ b/static/graph/graph.gen.js @@ -0,0 +1,824 @@ +export const nodes = [ + { + "id": 1, + "name": "Advent of Code in Coq - Day 1", + "group": 3, + "tags": [ + "Advent of Code", + "Coq" + ], + "url": "https://danilafe.com/blog/00_aoc_coq", + "value": 16279 + }, + { + "id": 2, + "name": "Compiling a Functional Language Using C++, Part 0 - Intro", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/00_compiler_intro", + "value": 7087 + }, + { + "id": 3, + "name": "Compiling a Functional Language Using C++, Part 1 - Tokenizing", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/01_compiler_tokenizing", + "value": 10885 + }, + { + "id": 4, + "name": "Compiling a Functional Language Using C++, Part 2 - Parsing", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/02_compiler_parsing", + "value": 16450 + }, + { + "id": 5, + "name": "Compiling a Functional Language Using C++, Part 3 - Type Checking", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/03_compiler_typechecking", + "value": 27055 + }, + { + "id": 6, + "name": "Compiling a Functional Language Using C++, Part 4 - Small Improvements", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/04_compiler_improvements", + "value": 10003 + }, + { + "id": 7, + "name": "Compiling a Functional Language Using C++, Part 5 - Execution", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/05_compiler_execution", + "value": 28832 + }, + { + "id": 8, + "name": "Compiling a Functional Language Using C++, Part 6 - Compilation", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/06_compiler_compilation", + "value": 22584 + }, + { + "id": 9, + "name": "Compiling a Functional Language Using C++, Part 7 - Runtime", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/07_compiler_runtime", + "value": 7410 + }, + { + "id": 10, + "name": "Compiling a Functional Language Using C++, Part 8 - LLVM", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/08_compiler_llvm", + "value": 23607 + }, + { + "id": 11, + "name": "Compiling a Functional Language Using C++, Part 9 - Garbage Collection", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/09_compiler_garbage_collection", + "value": 25989 + }, + { + "id": 12, + "name": "Compiling a Functional Language Using C++, Part 10 - Polymorphism", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/10_compiler_polymorphism", + "value": 42606 + }, + { + "id": 13, + "name": "Compiling a Functional Language Using C++, Part 11 - Polymorphic Data Types", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/11_compiler_polymorphic_data_types", + "value": 19586 + }, + { + "id": 14, + "name": "Compiling a Functional Language Using C++, Part 12 - Let/In and Lambdas", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/12_compiler_let_in_lambda", + "value": 49622 + }, + { + "id": 15, + "name": "Compiling a Functional Language Using C++, Part 13 - Cleanup", + "group": 2, + "tags": [ + "C and C++", + "Functional Languages", + "Compilers" + ], + "url": "https://danilafe.com/blog/13_compiler_cleanup", + "value": 44195 + }, + { + "id": 16, + "name": "A Language for an Assignment - Homework 1", + "group": 4, + "tags": [ + "Haskell", + "Python", + "Algorithms", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/00_cs325_languages_hw1", + "value": 21326 + }, + { + "id": 17, + "name": "Advent of Code in Coq - Day 8", + "group": 3, + "tags": [ + "Advent of Code", + "Coq" + ], + "url": "https://danilafe.com/blog/01_aoc_coq", + "value": 46511 + }, + { + "id": 18, + "name": "A Language for an Assignment - Homework 2", + "group": 4, + "tags": [ + "Haskell", + "Python", + "Algorithms", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/01_cs325_languages_hw2", + "value": 8949 + }, + { + "id": 19, + "name": "Learning Emulation, Part 1", + "group": 1, + "tags": [ + "C and C++", + "Emulation" + ], + "url": "https://danilafe.com/blog/01_learning_emulation", + "value": 3387 + }, + { + "id": 20, + "name": "A Language for an Assignment - Homework 3", + "group": 4, + "tags": [ + "Haskell", + "Python", + "Algorithms", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/02_cs325_languages_hw3", + "value": 19899 + }, + { + "id": 21, + "name": "Learning Emulation, Part 2", + "group": 1, + "tags": [ + "C and C++", + "Emulation" + ], + "url": "https://danilafe.com/blog/02_learning_emulation", + "value": 3965 + }, + { + "id": 22, + "name": "Learning Emulation, Part 2.5 - Implementation", + "group": 1, + "tags": [ + "C and C++", + "Emulation" + ], + "url": "https://danilafe.com/blog/03_learning_emulation", + "value": 4881 + }, + { + "id": 23, + "name": "Posts", + "group": 1, + "tags": [ + + ], + "url": "https://danilafe.com/blog/_index", + "value": 383 + }, + { + "id": 26, + "name": "Rendering Mathematics On The Back End", + "group": 1, + "tags": [ + "Website", + "Nix", + "Ruby", + "KaTeX" + ], + "url": "https://danilafe.com/blog/backend_math_rendering", + "value": 13994 + }, + { + "id": 27, + "name": "Math Rendering is Wrong", + "group": 1, + "tags": [ + "Website" + ], + "url": "https://danilafe.com/blog/math_rendering_is_wrong", + "value": 10313 + }, + { + "id": 28, + "name": "Thoughts on Better Explanations", + "group": 1, + "tags": [ + "Language Server Protocol" + ], + "url": "https://danilafe.com/blog/better_explanations", + "value": 5815 + }, + { + "id": 29, + "name": "Declaratively Deploying Multiple Blog Versions with NixOS and Flakes", + "group": 1, + "tags": [ + "Website", + "Nix" + ], + "url": "https://danilafe.com/blog/blog_with_nix", + "value": 18272 + }, + { + "id": 30, + "name": "How Many Values Does a Boolean Have?", + "group": 5, + "tags": [ + "Java", + "Haskell", + "C and C++" + ], + "url": "https://danilafe.com/blog/boolean_values", + "value": 12955 + }, + { + "id": 31, + "name": "Pleasant Code Includes with Hugo", + "group": 1, + "tags": [ + "Hugo" + ], + "url": "https://danilafe.com/blog/codelines", + "value": 11846 + }, + { + "id": 32, + "name": "Formalizing Dawn in Coq", + "group": 3, + "tags": [ + "Coq", + "Dawn", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/coq_dawn", + "value": 20615 + }, + { + "id": 33, + "name": "A Verified Evaluator for the Untyped Concatenative Calculus", + "group": 3, + "tags": [ + "Dawn", + "Coq", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/coq_dawn_eval", + "value": 31852 + }, + { + "id": 34, + "name": "Formalizing Dawn in Coq", + "group": 3, + "tags": [ + "Coq", + "Dawn", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/./coq_dawn", + "value": 20615 + }, + { + "id": 36, + "name": "Proof of Inductive Palindrome Definition in Coq", + "group": 3, + "tags": [ + "Coq" + ], + "url": "https://danilafe.com/blog/coq_palindrome", + "value": 8177 + }, + { + "id": 37, + "name": "Building a Basic Crystal Project with Nix", + "group": 6, + "tags": [ + "Crystal", + "Nix" + ], + "url": "https://danilafe.com/blog/crystal_nix", + "value": 5981 + }, + { + "id": 38, + "name": "Building a Crystal Project with Nix, Revisited", + "group": 6, + "tags": [ + "Crystal", + "Nix" + ], + "url": "https://danilafe.com/blog/crystal_nix_revisited", + "value": 9141 + }, + { + "id": 39, + "name": "Setting Up Crystal on ARM", + "group": 6, + "tags": [ + "Crystal", + "ARM" + ], + "url": "https://danilafe.com/blog/crystal_on_arm", + "value": 5414 + }, + { + "id": 40, + "name": "DELL Is A Horrible Company And You Should Avoid Them At All Costs", + "group": 1, + "tags": [ + "Electronics" + ], + "url": "https://danilafe.com/blog/dell_is_horrible", + "value": 21686 + }, + { + "id": 41, + "name": "Haskell Error Checking and Autocompletion With LSP", + "group": 5, + "tags": [ + "Haskell", + "Language Server Protocol" + ], + "url": "https://danilafe.com/blog/haskell_language_server", + "value": 10468 + }, + { + "id": 42, + "name": "Using GHC IDE for Haskell Error Checking and Autocompletion", + "group": 5, + "tags": [ + "Haskell", + "Language Server Protocol" + ], + "url": "https://danilafe.com/blog/haskell_language_server_again", + "value": 4758 + }, + { + "id": 43, + "name": "Time Traveling In Haskell: How It Works And How To Use It", + "group": 5, + "tags": [ + "Haskell" + ], + "url": "https://danilafe.com/blog/haskell_lazy_evaluation", + "value": 25280 + }, + { + "id": 44, + "name": "Approximating Custom Functions in Hugo", + "group": 1, + "tags": [ + "Hugo" + ], + "url": "https://danilafe.com/blog/hugo_functions", + "value": 4034 + }, + { + "id": 45, + "name": "Introducing Matrix Highlight", + "group": 1, + "tags": [ + "Matrix", + "Project", + "Matrix Highlight" + ], + "url": "https://danilafe.com/blog/introducing_highlight", + "value": 7481 + }, + { + "id": 46, + "name": "Local Development Environment for JOS and CS 444", + "group": 1, + "tags": [ + "C and C++", + "OS Dev" + ], + "url": "https://danilafe.com/blog/jos_local", + "value": 4839 + }, + { + "id": 47, + "name": "Lambda Calculus and Church Encoded Integers", + "group": 1, + "tags": [ + "Lambda Calculus" + ], + "url": "https://danilafe.com/blog/lambda_calculus_integers", + "value": 10351 + }, + { + "id": 48, + "name": "Digit Sum Patterns and Modular Arithmetic", + "group": 1, + "tags": [ + "Ruby", + "Mathematics" + ], + "url": "https://danilafe.com/blog/modulo_patterns", + "value": 39663 + }, + { + "id": 49, + "name": "New Look, New Features!", + "group": 1, + "tags": [ + "Website" + ], + "url": "https://danilafe.com/blog/new_look", + "value": 727 + }, + { + "id": 51, + "name": "JavaScript-Free Sidenotes in Hugo", + "group": 1, + "tags": [ + "Website", + "Hugo", + "CSS" + ], + "url": "https://danilafe.com/blog/sidenotes", + "value": 7762 + }, + { + "id": 52, + "name": "Creating Recursive Functions in a Stack Based Language", + "group": 4, + "tags": [ + "Programming Languages" + ], + "url": "https://danilafe.com/blog/stack_recursion", + "value": 15694 + }, + { + "id": 53, + "name": "A Look Into Starbound's File Formats", + "group": 1, + "tags": [ + "Starbound" + ], + "url": "https://danilafe.com/blog/starbound", + "value": 11817 + }, + { + "id": 54, + "name": "Switching to a Static Site Generator", + "group": 1, + "tags": [ + "Website" + ], + "url": "https://danilafe.com/blog/static_site", + "value": 3402 + }, + { + "id": 56, + "name": "A Typesafe Representation of an Imperative Language", + "group": 4, + "tags": [ + "Idris", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/typesafe_imperative_lang", + "value": 20619 + }, + { + "id": 57, + "name": "Meaningfully Typechecking a Language in Idris", + "group": 4, + "tags": [ + "Haskell", + "Idris", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/typesafe_interpreter", + "value": 13655 + }, + { + "id": 58, + "name": "Meaningfully Typechecking a Language in Idris, Revisited", + "group": 4, + "tags": [ + "Idris", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/typesafe_interpreter_revisited", + "value": 16100 + }, + { + "id": 59, + "name": "Meaningfully Typechecking a Language in Idris, With Tuples", + "group": 4, + "tags": [ + "Idris", + "Programming Languages" + ], + "url": "https://danilafe.com/blog/typesafe_interpreter_tuples", + "value": 10235 + }, + { + "id": 60, + "name": "Type-Safe Event Emitter in TypeScript", + "group": 1, + "tags": [ + "TypeScript" + ], + "url": "https://danilafe.com/blog/typescript_typesafe_events", + "value": 5589 + } +]; +export const edges = [ + { + "from": 2, + "to": 3 + }, + { + "from": 2, + "to": 4 + }, + { + "from": 2, + "to": 5 + }, + { + "from": 2, + "to": 6 + }, + { + "from": 2, + "to": 7 + }, + { + "from": 2, + "to": 8 + }, + { + "from": 2, + "to": 9 + }, + { + "from": 2, + "to": 10 + }, + { + "from": 2, + "to": 11 + }, + { + "from": 2, + "to": 12 + }, + { + "from": 2, + "to": 13 + }, + { + "from": 2, + "to": 14 + }, + { + "from": 2, + "to": 15 + }, + { + "from": 3, + "to": 2 + }, + { + "from": 3, + "to": 4 + }, + { + "from": 4, + "to": 5 + }, + { + "from": 5, + "to": 6 + }, + { + "from": 6, + "to": 7 + }, + { + "from": 7, + "to": 8 + }, + { + "from": 8, + "to": 9 + }, + { + "from": 9, + "to": 10 + }, + { + "from": 10, + "to": 11 + }, + { + "from": 11, + "to": 12 + }, + { + "from": 12, + "to": 10 + }, + { + "from": 12, + "to": 5 + }, + { + "from": 12, + "to": 8 + }, + { + "from": 12, + "to": 13 + }, + { + "from": 13, + "to": 12 + }, + { + "from": 13, + "to": 4 + }, + { + "from": 13, + "to": 14 + }, + { + "from": 14, + "to": 12 + }, + { + "from": 14, + "to": 7 + }, + { + "from": 14, + "to": 8 + }, + { + "from": 14, + "to": 6 + }, + { + "from": 14, + "to": 15 + }, + { + "from": 15, + "to": 14 + }, + { + "from": 18, + "to": 16 + }, + { + "from": 21, + "to": 19 + }, + { + "from": 22, + "to": 19 + }, + { + "from": 26, + "to": 2 + }, + { + "from": 26, + "to": 27 + }, + { + "from": 31, + "to": 2 + }, + { + "from": 33, + "to": 34 + }, + { + "from": 38, + "to": 37 + }, + { + "from": 42, + "to": 41 + }, + { + "from": 44, + "to": 31 + }, + { + "from": 51, + "to": 2 + }, + { + "from": 58, + "to": 57 + }, + { + "from": 59, + "to": 57 + }, + { + "from": 59, + "to": 58 + } +]; diff --git a/static/index.st b/static/index.st new file mode 100644 index 0000000..639031e Binary files /dev/null and b/static/index.st differ