started writings

src/css/style.css

@@ -1,3 +1,8 @@
+@font-face {
+  font-family: 'atkinson';
+  src: url(/res/atkinson-regular.woff2);  
+}
+
 @font-face {
   font-family: 'merriweather';
   src: url(/res/merriweather-regular.woff2);
@@ -9,11 +14,11 @@
 }
 
 body {
-  font-family: merriweather;
+  font-family: 'merriweather';
   background-image: url("/res/grey.png");
   background-repeat: repeat;
   padding: 20px 10px 20px;
-  line-height: 1.75em;
+  line-height: 1.5em;
   height: 100%;
   max-width: 40em;
   display: flex;
@@ -22,14 +27,21 @@ body {
 
 main {
   border-radius: 15px;
-  padding: 15px;
+  word-spacing: 0.12em;
+  padding: 1.2em;
   background-color: #ffeedd;
   margin: 2px;
-  width: 100%
+  width: 100%;
+  font-size: 1.2em;
 }
 
 code {
+  display: inline-block;
   font-family: cascadia;
+  font-size: 0.9em;
+  background: #1e1e22;
+  color: #dddde1;
+  padding: 0.1em 0.5em 0.1em;
 }
 
 table {
@@ -62,8 +74,8 @@ h1 {
 }
 
 h2 {
-  margin-top: 0em;
+  margin-top: 1em;
-  margin-bottom: 0em;
+  margin-bottom: 0.5em;
 }
 
 section {

src/hyperspace/index.md

@@ -12,5 +12,6 @@
 * [psychocool](https://psychcool.org/links)
 * [nenrikido](https://nenrikido.neocities.org/)
 * [incessantpain](https://incessantpain.neocities.org/)
+* [ngmi](https://ngmi.neocities.org/home)
 ## cool webrings
 * [neocratives](http://neocreatives.byethost5.com/)

src/index.md

@@ -1,23 +1,26 @@
 # logan's site
 ## about
 My name is Logan Gatlin, and upon this Intel NUC8i3 I shall build my kingdom. I
-am from the United States, where I was born in 2003. In 2025 I will receive my
+am from the United States, where I was born in 2003. In 2025, I will receive my
-bachellors in Computer Science from the [University of Texas at San
+bachelor's degree in Computer Science from the [University of Texas at San
 Antonio](https://utsa.edu).
 
 ## site map
-* [my git server](https://git.lgatlin.dev/logan) - _Private forgejo instance_
+* [writings](/writings/) - _My thoughts_
 * [software](/software) - _Awesome software projects_
 * [books](/books) - _Reading corner_
 * [music](/music) - _Sick tunes_ 
-* [toybox](/toybox) - _Web experiences_
+* [toy box](/toybox) - _Web experiences_
-* [hyperspace](/hyperspace) - _Everything world wide web_
+* [hyperspace](/hyperspace) - _Everything World Wide Web_
-
-## meta
 * [server info](/server-info.html) - _Technical information about this server_
 * [style guide](/style-guide.html) - _Formatting rules for this site_
 
+## external links
+* [my git server](https://git.lgatlin.dev/logan)
+* [github](https://github.com/Xterminate1818)
+* [resume](/resume.pdf)
+
 <section>
-<img src="favicon.gif" style="width: 10em;" alt="Lain animation"> <br>
+  <img src="favicon.gif" style="width: 10em;" alt="Lain animation"> <br>
-<em>If you're not remembered, then you never existed</em>
+  <em>If you're not remembered, then you never existed</em>
 </section>

src/js/highlight.js

@@ -979,4 +979,4 @@ className:"number",
 begin:"\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b"
 },{className:"number",begin:e.C_NUMBER_RE+"\\b",relevance:0},t,g,s],r=[...b]
 ;return r.pop(),r.push(i),l.contains=r,{name:"YAML",case_insensitive:!0,
-aliases:["yml"],contains:b}}})();hljs.registerLanguage("yaml",e)})();
+aliases:["yml"],contains:b}}})();hljs.registerLanguage("yaml",e)})();

src/toybox/the-crypt/index.md

@@ -18,7 +18,7 @@ compiled for the web if you want to host it locally
 ## embed
 ```html
 <iframe
-    src="https://lgatlin.dev/toybox/the-crypt/TheCrypt.html">
+    src="https://lgatlin.dev/toybox/the-crypt/TheCrypt.html"
     width="100%" height="auto"
     style="aspect-ratio: 16/9;">
 </iframe>

src/writings/1-build-systems.md

@@ -0,0 +1,69 @@
+# on build systems
+Recently I have been thinking about what makes for good build system. I 
+want to analyze the major pain points I have encountered building software,
+and identify where these systems go wrong. To do this I have picked several
+languages I am already familiar with to use as case studies
+## definitions
+I think of build systems as a very broad category of software; the goal of
+which is to automate the process of packaging or executing other software.
+This typically involves several subtasks. Resolving dependencies, compiling,
+interpreting, linking, deploying, packaging, executing - software that does one
+or more of these things counts as a build system in my book
+## c and c++
+The C family of languages has a quite complicated ecosystem of competing build
+systems. To start with, there are the compilers themselves: 
+[GCC](https://gcc.gnu.org/) and [Clang](https://clang.llvm.org/). A typical 
+invocation of looks like this:
+```bash
+cc main.c foo.c bar.h -Iinclude/ -Llib/ -O2 -oProgram
+```
+This is quite verbose as far as build commands go. The path of every source file
+must be specified, as well as separate folders for library headers and object
+files. Most software also makes use of numerous compiler flags, most of which
+have incredibly cryptic names. 
+
+To compile a C project using only the compiler requires first learning
+its structure, wrangling each of its dependencies manually, and reading
+documentation to find the appropriate build flags for your platform. For any
+non-trivial program, simply typing the build command becomes a challenge
+
+## make 
+The problems introduced by the C family of compilers have proven intractable,
+and so another layer of abstraction is necessary. Makefile is a rudimentary
+scripting language primarily used to build C family languages.
+```make
+# Example Makefile taken from:
+# https://www.cs.colby.edu/maxwell/courses/tutorials/maketutor/
+CC=gcc
+CFLAGS=-I.
+DEPS=hellomake.h
+OBJ=hellomake.o hellofunc.o 
+
+%.o: %.c $(DEPS)
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+hellomake: $(OBJ)
+	$(CC) -o $@ $^ $(CFLAGS)
+```
+Makefiles attempt to abstract away the complexity of the C compilation process.
+Variables and pattern matching of file names are particularly well suited for
+managing compiler flags and object files. However, by far the most attractive
+feature of Makefiles is the ability to simply type `make` to compile the entire
+program.
+
+As software becomes more complex, so too does the task of building it. The 
+limitations of C make this problem particularly egregious, given its fragile
+dependency resolution and lack of meta-programming. Makefiles have attempted
+to bridge this gap, and are a Turing-Complete language in their own right. 
+The [Makefile which builds the Linux kernel](https://github.com/torvalds/linux/blob/master/Makefile)
+is over 2000 lines as of writing. The massive demands placed on this
+intermediary language have exposed its weak points, mainly that it is
+stringly-typed and full of cryptic, unintuitive syntax. Maintaining  complex
+Makefiles contributes to the difficulty of building software almost as much as
+it reduces
+
+## cmake
+When I first learned about CMake and what it does, I actually laughed out loud.
+I am lucky enough to have never written a CMake file, so this section will
+be brief. Just as Makefiles abstract away the complexity of building C, CMake
+abstracts away the complexity of building Makefiles.

src/writings/index.md

@@ -0,0 +1,2 @@
+# writings
+* [on build systems](./1-build-systems.html)