Hi, I'm vs-123. I am a passionate programmer. I have a deep-seated interest in the inner workings of computers. My interests primarily revolve around low-level development. I enjoy bridging the gap between hardware and software.

C is my primary language of choice with a specific fondness for C99. I appreciate its efficiency and the granular control it offers over machine state, and I find its philosophy aligns perfectly with my interest in building lean & transparent systems.

• C -- C is my primary vehicle for exploring the machine state. I highly value and enjoy the transparency, lean nature and the fine control it offers me over memory and hardware

• C++ -- C++ has been my bridge from high-level abstractions to systems programming. I still use it when the project requires complex architectural patterns or modern abstractions

• Rust -- Rust used to be my daily-driver. Rust had shaped my understanding of memory safety and has equipped me with key concepts such as memory ownership, borrowing, pointer aliasing, unsafe optimisations, etc.

• WASM -- I treat the web as just another compilation target. Sometimes I write projects in C/C++/Rust which I wish to be able to use on my browser, in such cases I compile to WASM

• Regex -- Beyond just using it, I've implemented a PCRE-compatible engine called regen from scratch in C99, in order to understand how it works deep under the hood. This has given me deep insights on not just regex, but also non-finite automata and backtracking

• Go -- Go is my favourite high-level language. I enjoy the minimalism and simplicity it offers to me along with its C-ish vibes. I use it for systems involving networking

• Python -- I use Python as a scripting language, as a glue language. I use it mostly for writing quick scripts that are slightly more complex for bash, quick prototypes of algorithms, visualising data and making statistical observations and verification, like that of ystar

• Lua -- I enjoy Lua's simplicity for a scripting language, and its embeddable nature. I use it primarily for my Neovim configuration.

• Haskell -- Haskell is my playground and laboratory for parser algorithms. I use Haskell for writing quick parser algorithms, as well as testing them. It's functional nature and expressive type system makes it a perfect environment for me to test formal grammars

• HTML5, CSS, JS -- These languages have been my entry point into programming. JavaScript is the first programming language I've learnt. These foundations have also eventually led me to Electron, which had piqued my interest in GUI application development.

• TypeScript -- TypeScript was my first encounter with a formal type system. Initially I disliked its statically-typed nature, but after a while of using it, I had eventually learnt to appreciate type systems in general. The fact that I could catch potential errors before runtime was a fascinating idea to me, coming from JavaScript where somehow 0 == "0" and "0" == [] are true but 0 == [] is false and ('b' + 'a' + + 'a' + 'a').toLowerCase() becomes "banana"

• Linux & BSD -- I enjoy exploring the philosophies of various platforms including *nix ecosystem, which also includes Linux and BSD. Although Void Linux is my daily driver, I admire the BSD family committing to the true UNIX philosophy. I especially admire the idea of "do one thing and do it well", which is pretty evident in the BSD userland and architecture

• Vim -- Vim is the first text editor I tried after months of VSCode. I found the idea of using my entire keyboard to manipulate text quite interesting. Vim has been my entry point into keyboard-oriented text editors

• Emacs -- Emacs was my next daily-driver as a text editor. I enjoyed its highly customisable nature. But what stood out for me the most is the idea that it's a "self-documenting editor". I highly appreciated its built-in help features, especially C-h chords

• Neovim -- Neovim is my current text editor of choice, I use it for programming most of my projects, including this README. I occasionally use ed for making quick edits

• CMake -- CMake is my primary meta-buildsystem of choice when I write C and C++ projects. I enjoy its ability to general build files for various buildsystems. This allows my projects, which I build with GNU Make, to be built on someone's Windows machine with Visual Studio

• Git -- Git is my favourite version control system. I use it frequently when I develop projects. It allows me to manage the evolution of my source code, which aids in keeping the project tidy and organised

• CI/CD & Docker -- I utilise GitHub actions and Docker to automate the testing of my projects across different environments, and also to streamline binary distribution

• LaTeX & Markdown -- These are my tools of choice when it comes to technical documentation and making general notes

• regen -- A PCRE-compatible, regular-expressions engine written in C99. Supports various features including capture groups, backreferences, zero-width lookaround assertions, character classes, and more. No external libraries were used
• ystar -- A xorshift64* PRNG implementation in C99 with my own custom constants, tested and verified with various statistical tests including Wald-Wolfowitz Runs Test and Lag-1 Correlation Test. PLOTS AVAILABLE IN README
• bpvm -- A simple, fully-functional BytePusher VM implementation in C99. SCREENSHOTS AVAILABLE IN README
• halloc -- A dead-simple, thread-safe, general-purpose, explicit-freelist heap allocator library written in C99
• barc -- A lexicographical permutation-based BWT + local frequency-adaptive MTF transform + multi-byte chunked RLE file-compressor archive utility tool written in C99. This project uses no OS-specific/POSIX/external libraries in order to keep it portable
• mbf -- A custom BF implementation, with the addition of macros
• dstr -- A dead-simple dynamic-string library written in C89. Supports printf-style formatters for string concatenation, written from scratch
• mswpr -- Fully functional Minesweeper implementation in C99, using my own ystar PRNG for mine generation and placement. Screenshots available in README
• kernel -- A dead-simple kernel written in C99 with LLVM toolchain
• tegen -- A recursive, stochastic text generator for Rust
• auc -- A cross-platform auto-clicker in C99
• Royal Hemlock Theme -- Soothing royal-blue light-theme for Emacs. Screenshots available in README

I find myself fascinated by the core mechanics of different programming languages and the way they're implemented. This often leads me to find myself exploring different compilers via Godbolt, where I read and understand the assembly generated by various different compilers. I find it enjoyable to learn and analyse how various compilers handle various optimisation passes and architecture specific optimisations. I treat the translation from code to machine instructions as a field of study in itself.

My time spent with Compiler Explorer has deeply influenced my development workflow. It has helped me develop a habit of making low-level optimisation decisions as I write code. This practice gives me a rough yet grounded intuition about the potential memory layout, cache locality and the precise state transitions the hardware performs during execution of my programs.

As a result of learning and analysing how different compilers target various ISAs, I've gained a well familiarity with several architectures including but not limited to x86-64, x86, MIPS, ARM32/64 and MPPA. This has allowed me to reason about code performance across a wide and diverse range of platforms.

This exposure with a diverse range of assemblies has granted me the advantage of being able to intuitively read and understand most assemblies, even for architectures I haven't formally encountered before. I find this skill incredibly helpful when debugging programs or reverse-engineering.

This grasp on assembly developed over the years, combined with my interest in language implementation, has led me to a much deeper understanding of the core mechanics of a computer. It allows me to evaluate the specific trade-offs and underlying philosophies offered by different programming languages from the POV of how they actually work under the hood.

In addition to code, I enjoy exploring the philosophies of different software and their communities. This curiosity drives my appreciation for Linux, UNIX, *nixes as well as the POSIX standard. I understand and appreciate the historical design patterns and the ideologies emerged historically. I find more interest in the "why" of a system's design more than I do in the "how" of its execution.

int add(int x, int y) {
   return x + y;
}

add:
   jr     $31
   addu   $2,$4,$5

addu $2,$4,$5   # (cycle 1)
jr              # $31 (cycle 2)
nop             # (delay slot)

int main() {
   int y = 1;
   int z = 2;
   int x = y + z;
   
   return 0;
}

       section data
       section code
 main:
       push rbp
       mov rbp, rsp
       sub rsp, 24
 main_block0:
       mov r8, 1
       mov [rbp, -8], r8
       mov r8, 2
       mov [rbp, -16], r8
       mov r8, [rbp, -8]
       mov r11, [rbp, -16]
       add r8, r11
       mov [rbp, -24], r8
       mov rax, 0
       jmp main_epilog
 main_epilog:
       add rsp, 24
       pop rbp
       ret

 ...
 main_block0:
       mov r8, 1
       mov [rbp, -8], r8
       mov r8, 2
       mov [rbp, -16], r8
 ...

main:
    mov [rbp - 8], 1
    mov [rbp - 12], 2

int main() {
   return sizeof(int);
}

       section data
       section code
 main:
       push rbp
       mov rbp, rsp
 main_block0:
       mov rax, 8
       jmp main_epilog
 main_epilog:
       pop rbp
       ret

int main(void) {
   return 42;
}

main:
        mov     eax, 42
        ret

int main(void) {
   return 128;
}

main:
        mov     eax, 128
        ret

int main(void) {
   return 0;
}

main:
        xor     eax, eax
        ret