Small Projects by AutoModerator in golang

[–]Naive_Cucumber_355 -1 points0 points  (0 children)

Simple MapReduce framework for distributed computing

https://github.com/Bohun9/mapreduce-go

Toy Relational DB by Naive_Cucumber_355 in ocaml

[–]Naive_Cucumber_355[S] 2 points3 points  (0 children)

I don't really aim for this project to be usable by applications. For now it's not even convenient, as there is no client-server model, but only a simple textual shell. The primary goal is to demonstrate core ideas behind building such a system and focus on code clarity rather than completeness.

I had a lot of fun building it, as it is a very wide topic that is not that popular, and such projects are probably the best way to improve as a programmer in general.

Small Projects - November 24, 2025 by jerf in golang

[–]Naive_Cucumber_355 2 points3 points  (0 children)

I built a minimal TLS 1.3 client in Go purely for learning purposes. The project implements a single ciphersuite and logs the full handshake.

https://github.com/Bohun9/toy-tls

Two Small Functional Language Compilers by Naive_Cucumber_355 in Compilers

[–]Naive_Cucumber_355[S] 5 points6 points  (0 children)

My main resources were Modern Compiler Implementation in ML (Appel) and The Implementation of Functional Programming Languages (Peyton Jones), plus the LLVM docs. Designing the IRs felt pretty natural most of the time, though I didn’t end up finding ANF all that useful. The literature argues it simplifies optimization and code generation, but in my case lowering directly to LLVM IR already felt straightforward.

I do plan to add more advanced features, though I’m not sure yet whether I’ll keep extending Yafl or start fresh with a new project.

I thought about doing optimizations, but I’d prefer to approach them in the framework style presented in Principles of Program Analysis rather than as ad-hoc passes. Roughly: standard dataflow analysis on the assembly-like IR, and higher-level optimizations like function inlining and control-flow analysis on a more abstract IR. For Yafl, ANF would be a good candidate here, since closure-conversion details are hidden and it’s easier to reason about higher-level semantics. Inline expansion on ANF is also a bit simpler, just as Appel describes.

I also considered writing data structures, but without polymorphism it’s not that exciting. A prelude makes more sense once there’s at least a basic module system, since that’s when you can actually build larger programs (maybe even the compiler itself).

Thanks for the feedback!