Disclaimer: I think the title is misleading. These goals are not meant to for 2021 solely. I'll probably keep myself busy this year with projects while the pandemic continues to rage on, since I'm not meeting any people. That being said, it's still the new year, and it's nice to think of some projects and goals to look forward to for the year. Likely these goals will continue on at least until 2022, but here's some leisure projects I'd like to take on.
Learning new programming languages
I love learning new programming languages. My top two candidates currently are
Rust, because I've heard so much about it -- a great type system, memory safety, blazing performance, support for functional programming, low-level memory access, etc. It's an up and coming language. I'd like to replace my
C/C++ needs with it eventually.
Lisp... for no good reason other than I enjoy functional programming. Pure functional programming can be so much easier to maintain than object-oriented code (although I think it comes more from the purity and than being a functional language) and so I'd like to try the ancestor of all functional programming languages.
PureScript are also on my list, but I'll reserve that for my web dev section below.
This summer, I started my first stabs at web development, and wrote a blog entry on how I enjoyed web development. My experience culminated in this very website. However, throughout the latter half of the year, I ended up learning more web development. In particular, I used
Node.js to build backends, and learned how HTTP requests work. On that end, I'd like to rebuild this static website and organize it into a proper frontend and backend. Maybe I'll get a more powerful backend, and even host some server-side demos with frontends on my website.
I want to avoid writing
PureScript, because I've unfortunately found
TypeScript, because I think it has relatively widespread adoption and because it's a superset of
PureScript, because I like to be a
Haskell fanboy and it just sounds fun to use.
This is probably going to be a lot smaller project than the other two above. I've always wanted to implement a slew of classic arcade games in various different programming languages. I currently don't have a major interest in game development, but creating games tend to be the most interactive and well-scoped projects one can work on.
So far, I already have created:
- Guess the number
- Flappy bird
At minimum, other games I want to create:
They all shouldn't be hard, it'll just be a matter of me getting to it. I believe I created snake for my introductory computer science class ages ago (aside: it was a great class. The professor taught us programming by creating games -- i.e. frogger, snake, asteroids, etc. What a fun way to motivate and interact with students). Likely I'll tie it in with goal #1: these games will be projects for me to learn new languages.
Sometime this summer (before Queen's Gambit was out), I started playing chess again. I had played competitively during middle school, but I hadn't played seriously ever since.
My goal here is to create a chess AI powerful enough to consistently beat me. I'm not a great player by any means. I used to hover around 1300 USCF; these days I am between 1800 and 1900 on lichess. This project, I'd like to make with a higher level of polish than I normally give my pleasure projects. I'll add an opening database to it so it doesn't start moving rook pawns in the opening, and maybe even an endgame database, too. Maybe I'll add time controls. If I really get motivated, I might even make an app version for my phone.
Writing code is a significant portion of software development, so it seems to make sense to optimize the environment I code in. I mostly code in JetBrains products, so it makes sense for me to really get to know IntelliJ IDEA. I also use Vim keybindings and often times use Vim when I don't want the overhead of an IDE, write code over ssh, or prototype, so it also makes sense for me to try and improve my Vim abilities from a simple user to a ... less inexperienced user.
I'll try and actually follow Bram Moleenaar (the author of Vim)'s advice on text editing, which I had linked in my resource blog.
(Speaking of Bram Moleenaar, a fun aside: the original author of
vi, Bill Joy, also helped developed the BSD operating system and co-founded Sun Microsystems. Which also reminds me of John Hennessy, 2017 Turing Award Laureate, father of RISC architecture, co-founder of MIPS, ex-Stanford University President... there are people).
Real World Haskell
I don't know why I like Haskell. Maybe it's because I think it's "cool" and I want to feel good about myself (maybe like Arch Linux users). I hope not, but I fear that's the reason. I still don't think I'll write something that I'll actually use in Haskell.
But I wonder if that's because I'm not used to functional programming; I still find iterative, object-oriented programming a lot easier. Perhaps I should try to build tools that work with Haskell. Real World Haskell is a behemoth of a tome that has all the resources for that end. I'll try to take a crack at it, see if I can create something useful with Haskell -- in particular, I'm thinking of creating a server backend with
Last year, I created a rudimentary SAT Solver in Haskell using the DPLL algorithm. This year, I want to try my luck in building a SMT Solver.
Implement self-balancing trees
Probably the simplest project on here. There's always plenty of balanced trees out there, including red-black trees in the Linux CFS Scheduler, size-balanced binary trees in Haskell's Map, and B-Trees in MySQL(and other SQL engines). However, I've never ever implemented self-balancing trees from scratch, so seems like a good experience to have.
I want to create a rudimentary language capable of compiling itself.
I think most parts will be okay, but creating the compiler in the language and having it emit assembly is probably the biggest challenge.
Programming Language Theory
I still have a lot (by a lot, I mean a lot) to learn about programming language theory.
PLFA is a book about PL theory using Agda, a proof assistant based on
Given my current and former background with
Haskell and formal methods, this seems like an apt way to learn PL theory.