Outside of the code
Before I jump into my experience coding, here’s a little bit about me.
I’m a high school senior who had to go through the recent experience of college applications. It definitely takes a A LOT of time, so here’s the obligatory “plan it out in advance” notice if you’re reading this as a high schooler.
Outside of the academic sphere, I’m a HUGE Star Wars fan. Prettly much ever since preschool I’ve had a general obsession with the universe and games/movies/shows.
I also have an affinity for coffee-making & coffee-tasting. I love making my own drinks, especially when I see a nice drink to try from online or decide to (successfully) put together a combination of my own. I’ll also randomly decide to try different coffee shops within a feasible drivable distance whenever I can.
The Origin Story
I’ve been coding since around the time I was in 7th-8th grade. Sure, I wrote a little code before then, but I like to say I started in 7th grade since that’s when I really found an area I liked writing in.
I started with iOS Development, which was with Swift 2 if I remember correctly. That was my first real dive into programming, and I learned a lot about C-style language syntax, general program flow, and actually understanding what I wrote.
After I realized I had to pay $100/year to publish apps on the iOS Store, I turned away from iOS Development for the next year, instead pursuing Android development. Java was relatively straightforward to pick up since the syntax was pretty similar to Swift’s.
Around the beginning of 8th grade, I published my first Android app to the Google Play Store (because it looked like you would expect a first app to look, it is no longer available publicly). For context, this was a time where I could not figure out the secrets to making good user interfaces, so you may very well have seen many constraint errors & overflowing elements if you opened these apps on a phone that wasn’t mine.
Fast forward a little, to around the middle of 8th grade, I saw an Instagram post about saying “Flutter is cool.” Curiously, I looked up Flutter, found a course to get started with it, and wrote primarily Flutter applications for the next few years.
Yes, I’m serious. My high school years of writing Flutter apps all stemmed from an Instagram post that I happened to scroll across one day in 8th grade, probably while I was bored in the car or something.
Here & Now
Moving on to where I am today. First, and probably most importantly, I can write much nicer code. With that also comes my ability to create (in my head anyways) generally nice user interfaces that follow general design guidelines.
I’ve also diverified off of solely developing mobile applications and have recently fell in love with Rust (it’s a beautiful language; I strongly recommend looking at it). I still like writing applications with Flutter, but I’m not afraid to work with native code (iOS, Android, JavaScript) for optimizations and native-only features (think Share Sheets, Web Workers, Fast Crypto, etc).
I’ve also reached the point where all I need is an understanding of the project & its requirements to work seamlessly with the best toolset to get the job done. I know it’s said a lot, but seriously, if you can understand how one programming language works, you’re pretty much set for writing code in nearly any other language (obviously with the help of Google & Stack Overflow).
In terms of stuff I’ve actually made, I’ve made a few open source packages (just look through my GitHub). I’ve also published a few apps on the iOS, Android, and macOS stores. My favorite (and most recent) is cClip.
If you want to see some more about my current projects, take a look at my projects page
About This Blog
I’m planning on having this be a generally lighthearted blog (I’ve written too much serious stuff in school, plus that gets boring quick) where I’ll explain various experiences I’ve had while writing different pieces of software. I’m also planning on doing some tutorial-style series that stemmed from my own experiences. Here’s my vision about the few types of posts I’ll have:
Experiences
For experiences, I’m envisioning the posts will be like an explanatory piece about a problem I may have encountered, an interesting path I had to take for some task/issue, or an explanation of why I decided to do something.
These posts will generally contain more diagrams and theoretical/logical explanations around their underlying task the post is about. It’ll be relatively low on actual code, since it’s more a description of my thought and planning processes.
A few examples of the posts (just off the top of my head, not committing to any of these yet) could be: “Planning out the structure of cClip”, “Why I rewrote cClip Direct in Rust”, or “Encryption Perfomance comparisons between Dart & Native code”.
All thsoe examples would probably have some diagrams regarding structure or graphs regarding performance implications. They wouldn’t be too heavy on code (though might have some). The main purpose would be to explain my thought process, experiment, or design structure.
Tutorials
These posts will be in a series-style manner (for the long tutorials especially) that provide an in-depth explanation of doing some code- or shell-related task. Usually, my ideas for these tutorials will come from stuff I’ve found hard to do and/or recommendations from others.
These will contain snippets of code (and/or shell commands) as well as availability of the full source-code on GitHub (when applicable). Depending on the length of the task at hand, the tutorial could be encompassed entirely in a single post, or may be spread across a series of posts. If across a series, I’ll update each post with links to the next/previous posts when created.
A few examples (again, no concrete committments here) could be: “Writing a fully cross-platform Flutter FFI plugin”, “Interfacing with Rust libraries in Flutter/iOS/macOS/Electron”, or “Creating an XOR-patched OpenVPN server”.
Like I mentioned before, the difficulty would range from beginner-level to relatively advanced. I’m hoping most of these posts will be easily replicable, especially since you’ll have the finished source code to reference yours with.