A memo analyzing the rhetorical choices of the paper introducing the Penrose software.
Penrose is of special interest to me as a project that uses programming language theory to devise three orthogonal languages with clear design goals and use cases for each. Furthermore, this technical paper was interesting to analyze because it describes a tool that can aid in creating more approachable technical papers, giving it a meta flair.
This memo and the Penrose paper can be helpful to understand how to write a good technical paper, especially in the domain of computer science. Many technical papers are too technical, too text-heavy, and have poor approachability, making them difficult to read. On the other hand, Penrose's paper is extremely approachable without very much background knowledge; for instance, its consistent use of diagrams, as well as the many other excellent design choices that this memo highlights.

In my senior year of high school, I learned the Clojure programming language, implemented a Lisp interpreter, and gave a presentation about the language.
This was created for my English 12 Senior Thesis project. I saw this as the perfect opportunity to study Clojure and compiler implementation, both of which I had wanted to learn for a while. I have shared these materials in the hopes that it will inspire someone else to learn Clojure and become invested in Lisp and programming language theory. These materials provide a solid plan for studying these topics, including a timetable and a massive amount of literature to read on the subject, most importantly the book Clojure for the Brave and True. Additionally, the presentation I prepared at the end provides a summary of the topics and can serve as a good starting point to understand the basics of the topics before delving in.
If you are interested in learning about how Lisp and programming languages work and how simple it is to make your own, I highly recommend looking at these resources.

A guide for assembling the Planck ortholinear keyboard.
This was written for my Technical Writing course to learn about writing instructions. Along with being a passionate computer scientist, I really enjoy mechanical keyboards and use a Planck keyboard every day. After all, a programmer is only as good as their tools, and the keyboard is my main one.
Mechanical keyboards are great because they last very long, are customizable, and are getting cheaper and more mainstream with each passing day. In particular, the Planck is excellent because its unique layout reduces finger strain and movement. I wrote this guide to spread my passion for mechanical keyboards and introduce new people to the topic in the hopes that they will go on to use and reap the rewards of mechanical keyboards as I have done. Sometimes it can be intimidating to work with hardware, especially when it's uncommon. I hope that this guide helps to make this subject and the hardware itself much more approachable. Furthermore, the Planck is simple to assemble; it can be done in about 20 minutes and requires only basic tools and no soldering or wiring.
If you are interested in learning about mechanical keyboards, ortholinear layouts, the Planck, or have one and want to assemble it, I highly recommend giving this a read.

A series of blog posts about the Clojure programming language.
This was written for my First Year Writing course. It teaches the basics of Lisp programming in general, through the Clojure language. Specifically, the first post introduces readers by explaining the origins of Lisp, why it is still used and innovated on today, and how to use it at a basic level. The second post actually teaches the basics of Clojure, including its most important syntax, semantics, and useful features. It contrasts Clojure to mainsteram languages to show how solutions written in the language can be clearer and more concise. Finally, the last post delves into Clojure's metaprogramming features -- the ability to write code that transforms into different code. It explains why this is so useful, how Lisp programmers often use it without realizing, and how to intentionally do it yourself.
I deeply enjoyed working on this project. It allowed me to reflect on what I had learned about Lisp and Clojure in the year before I worked on the blog. Furthermore, I had to make decisions about what are the most essential features of Lisp and Clojure to explain to people unfamiliar with it. Perhaps more important was figuring out how to frame this in an approachable and exciting way; Lisp often gets a bad rap for being quite different from mainstream programming languages so I would need to override any preexisting biases.
Overall this was a valuable project for me and I hope you enjoy reading it if you so choose, and become a fellow Clojure zealot if so.

A research proposal titled "Introducing Programming through Lisp".
This was written for my Technical Writing course in order to gain practice with writing practical research proposals and understanding their essential components.
In the proposal, I suggest researching whether Lisp programming languages are better for teaching introductory computer science compared to mainstream languages like Java or Python, on the basis that functional programming allows programmers to program at a higher level and avoid irritating limitations or mistakes. This would involve designing a custom Lisp programming language and a four week course for new Computer Science students to learn introductory computer science through Lisp.
Although I have yet to actually perform research in this topic, I hope to complete a Master's thesis in the future with a focus in programming language theory. This proposal could serve as a valuable jumping-off point for preparing a full thesis proposal. As I am passionate about Lisp programming and its power, I do hope that my thesis focuses on it in some way.
This may give you ideas for similar research that you could perform, or inspire you to learn about the benefits of Lisp if you are unaware (take a look at my blog for an introduction!) so please give it a read if you are interested!

An extended definition of the term "Context-free Grammars".
This was written for my Technical Writing course as a useful resource for budding linguists or computer scientists, especially those interested in programming language and compiler theory.
This definition provides a basic introduction to what context-free grammars are and how they can be used. There are some interesting computer science applications that could be discussed, but they are not included for the sake of brevity and keeping this approachable to a wide audience, especially new linguists.
By reading this definition, you will learn just what context-free grammars are, how they specify a language's rules, how you can apply these rules to a sentence in a language and visualize that application, why grammars are useful in practice, and finally some of the shortcomings of grammars and what they cannot do for us. With this definition in your toolkit, if you are so interested, you should have no problem reading basic research papers about context-free grammars, especially from the days when they were first introduced, or finding ways to use them in your projects.
As a computer science student with a strong interest in compiler theory, I enjoyed learning about this term and re-explaining it. I had to think back to when I was first learning the subject and determine what was important to know, what wasn't, and what I wish I had been taught but wasn't. The book Crafting Interpreters, which I have cited at the bottom of the definition, provided my introduction to the term and was very useful in writing this.