2023 was an interesting year for me. In the beginning of the year I completed several Ruby on Rails projects and learned a lot about Ruby, React, web development, and coding. But once you complete a few small projects with web development, you start to hit what has oftentimes been called “the intermediate plateau” and things go from encouraging to discouraging fairly quickly.

What is the intermediate plateau? For those unfamiliar, it comes up pretty often in workout culture, art instruction, language learning, and various other hobbies/skills. Put simply, going from beginner to early intermediate usually consists of big jumps in skill and ability. You feel good about it and want to continue. But once you go past advanced-beginner and hit early intermediate, the gap between intermediate and advanced is very big. You need to do a lot to go from early intermediate, to intermediate, to advanced intermediate, to eventually advanced. For example, to pass from N2 in Japanese to N1 (N1 being advanced and N2 being the intermediate stage) you need to go from knowing 6,000 words to 10,000 words. You’ll need to essentially DOUBLE your vocab to get into this advanced territory. That’s a lot of work.

I have a lot of experience in the intermediate plateau, I’d argue that I’ve lived in it for a long time. I have a lot of hobbies. I go to art class every weekend, I studied Japanese in college and have been self-studying ever since, I’m a proficient chef, and lastly I can hack a few scripts/websites as a software engineer.

But the problem is, how do you go from being someone that can put together scripts to someone that can contribute to an open source project? Or how do you go from drawing and painting studies to making paintings that can be sold? Or how do you go from manga and furigana (Japanese) to reading difficult native texts and speaking fluently in-person? The reality is that it’s going to take a long time, and persistence is key.

I switch around pretty regularly and that helps keep things interesting. I’ve noticed that whenever I take a break, get into another hobby, and then switch back, I come back with a deeper understanding that I didn’t have before. Some of the information I had trouble connecting previously has solidified, and now my brain can make deeper connections. Being mindful of breaks and break timing is something I’d like to have a better approach to. But even if you don’t take a break, it’s good to try new things within the discipline and to gain experience with new aspects of your craft. For example, if you mostly draw with pen and pencil, give charcoal a shot. Or pick up a brush and try acrylic for a bit. A new drawing/painting medium can help you have a better understanding of how the process translates beyond technique.

When it comes to software, I spent most of 2023 trying out different programming languages, and different frameworks, essentially different mediums. For reference, I’m a JavaScript, Ruby, and Ruby on Rails, and React developer and started the year as such.

I love Android phones and was interested in putting together a small Android app. This meant learning Kotlin, which is the main programming language for Android now that they’ve moved off of Java. If you’re not aware, Kotlin is interoperable with Java and Kotlin targets the JVM (but it can also compile into JavaScript! More on that later). Kotlin is developed by JetBrains.

Kotlin is an interesting programming language for somebody coming from the more dynamic world of Ruby/JavaScript. Kotlin was my first real experience in types, size, mutability, and fighting with a compiler. You never need to declare your types in Ruby/JavaScript, but in Kotlin you have that option. Kotlin will automatically figure it out in most cases, but say you want to build an empty array, you’ll need to declare the type:

var exampleArray = emptyArray<String>()

This kinda broke me at first. I realize that’s probably amusing to people who started with Java in their high school AP computer science class. But thinking about what your array would contain or declaring an empty array specifically was something that didn’t make sense to me. The more dynamic languages have abstracted away memory allocation and let you do whatever you want. If you want an empty array in Ruby, you just declare it, and Ruby will figure out the rest. 

To add to the confusion, Kotlin used different terminology for things. An array is a fixed size and a list is a mutable size, similar to Ruby/JavaScript. I remember struggling with these terminology flips when I was learning Ruby. Methods are functions, hash tables in Ruby are objects in JS. While mutability and size made sense on paper, I didn’t really understand the point until I started learning Rust (more on that later).

Kotlin has a growing ecosystem around it, including the Ktor web development framework, and the recent Compose Multiplatform. You’ll need to become familiar with Android Studio and IntelliJ IDEA to make use of these frameworks and technologies. I’m sure it’s simple enough for anyone who’s an Android-first developer. Ktor was less batteries-included than I was used to, and to make use of their templating language you need to upgrade to IntelliJ IDEA Ultimate. I eventually picked up the IntelliJ suite, but I stopped using Ktor due to this limitation originally. You could create an API application and then build whatever front end you wanted, but that didn’t seem useful to me when I could already do the same thing with Rails.

Android development was a lot of work; even putting together a small project is a lot of code. Jetpack Compose is the new way to style (CSS for Android, if you will), and even that felt like a ton of code just to get going. Then there’s the problem that none of this translates to an iOS application. With compose multiplatform, this will likely change. I felt that perhaps sticking to the web was a better idea than jumping into apps that aren’t multiplatform. I figured if I really wanted to make an Android app, something like Flutter would be a better idea going forward. So I put a pin in it and moved on to a few other things.

I noticed many job listings called for either Java and Spring Boot devs or C# and .NET devs. This makes sense, as both Java and C# are seen as the enterprise tech stacks. I decided to give C# a shot because I could take my skills with C# and apply them to Unity and game development. What horrible timing on my end! Unity announced its pricing changes and it was a PR disaster. While I still think Unity will be popular with game developers, I didn’t want to keep using an engine with such horrible leadership, and dropped Unity.

C# and .NET felt very good, however. C# isn’t too hard to learn and after learning about types, sizes, and mutability with Kotlin, I felt like C# was pretty easy, actually. Not much to say about the language itself.

.NET, while a solid framework in my opinion, needs to do something about their naming conventions. First, there’s a difference between ASP.NET Core and ASP.NET, .NET MAUI, etc. Once you get into the ASP.NET Core, you’ll find that there are different frameworks for handling web apps, such ASP.NET Core MVC, Razor Pages, and Blazor (they sound the same!). I mostly dove into ASP.NET core MVC as it was the approach I was most used to, and I built a small blog with it. Nothing fancy, but it was a good lesson overall. The main difficulty I faced was in learning the default authentication solutions built into ASP.Net Core, which weren’t apparent at first glance. To be honest, they’re not apparent in Rails either—Rails just asks you to install the devise gem. A gem in Ruby is the name of their libraries/packages. Either way, my big complaint about web apps is that user management, security, and authentication should be talked about more, especially in tutorials. Odds are, if you’re building a web app, it’s not just a blog anybody can contribute to. It’s going to have users, and it’s going to have a way to sign them in and out. Not securing an application is an easy way to screw yourself. Committing secret keys is another big problem too. Again, this isn’t really talked about. I guess you just need to commit them once, so you learn!

Overall, the experience was great! But the job I was hoping to apply for ended up being filled while I was learning. A big lesson I learned is that chasing different frameworks willy-nilly could take up too much time with minimal rewards. Fundamentally, a lot of these frameworks are just alternative ways to solve the same problem.

React is technically the next section of the Odin Project, and I spent quite a bit of time working on it. React recently went through some major changes, so the stuff I was learning in the Odin project was outdated, so I had to learn on my own (they’ve since updated it!). Turning a Rails app into an API-only app and then using React for the front end was the goal. I developed a small test application and was following a YouTube series about it. I learned a lot and feel fairly proficient in React.

Overall, React seems like it’d be useful for larger teams, since you can turn everything into small reusable components. But for a smaller scale application, it’s a lot of extra code to call the API, build your components, and style them, when a Rails application can provide you a lot of this functionality with Turbo and erb templates built into it. When you build a scaffold in Rails, it builds your views for you. You won’t need to make API calls and can still turn your application into an SPA if you integrate turbo frames. Authentication is easy since devise will work natively with Rails and you don’t have to worry about CORS.

The lesson here is that understanding the scope and need of a project is important before deciding a framework. There’s a second part to this lesson, once I get into game development, but first, on to TypeScript.

TypeScript is pretty amazing, and I definitely see myself using it more in the future. Rails recently dumped TypeScript, however, so I’m not sure if I’ll be using it much as a Rails dev. I kind of see the argument, in the sense that regular JavaScript will likely remain a big part of the web development industry, but on the flip side, TypeScript feels like it’ll continue to gain popularity. I guess we’ll just have to learn both!

Game development is full of engines and frameworks, and you can easily get lost. I started with Unity, but the drama with Unity had me looking for something else.

Godot looked promising, but the editor interface and the idea of GDScript seemed unappealing to me. I’m still considering it, but likely won’t use it.

I gave Bevy a shot, but realized I needed to understand Rust better before I could dig into it. 

I decided to give Dragonruby a shot, and I’m currently using it. Dragonruby doesn’t have a GUI and is pretty easy to develop with if you know Ruby. 

But the lesson here is that sometimes the framework doesn’t matter. The real work I needed to do was to figure out what kind of game I was making. More prep time there would’ve helped me, rather than spending hours trying to figure out which framework was perfect. No framework is perfect, you need just to build and ship! So going back to the previous lesson, yes, your framework matters, but it also doesn’t if you never make anything.

This isn’t a framework, but I worked with a Ruby mentor to learn testing. Testing with RSpec is Ruby’s most popular testing suite. I learned a lot about mocking and not exposing your API keys to GitHub (since I exposed my API keys in one of my mocked files). Testing is very powerful and something I want to get better at. I understand why things like bootcamps skip this, but it feels like an integral part of software development.

2023 was the year of AI. ChatGPT grew in popularity exponentially, and the back half of 2022 and early 2023 was filled with nonstop AI talk. I learned a bit about AI and tried AI for software development, and it was both useful and not useful. AI has already been pretty popular with software engineers via GitHub copilot. I really like GitHub copilot and didn’t really find ChatGPT to be better than it in any way. GPT is useful for asking questions, but it never cites sources, and a few times it hallucinated on me and made up methods. I hear other developers have a better experience with the paid version, but I’m not sure if I’d be willing to pay $20 a month for something that might be useful, when GitHub Copilot is $10 a month and very reliable. 

2024 will likely be an important year for AI discussion; more to come on that down the line.

I did a bit of volunteering and attempted to get into freelancing in 2023. The volunteering went well; I managed a nonprofit’s Squarespace site, updated and reformatted a lot of it, while adding in new pages they needed. I hooked up their donation service and their new Google Analytics tag to the site as well. Very simple, but they needed someone to do it. It wasn’t really what I was looking for in terms of experience, but it was good to work with someone and to have a project with clearly defined goals and things to do. The downside of course is that you don’t get any git commits, so nobody even knows you did it! I will likely pick up another volunteering opportunity this year.

Freelancing was interesting. Checking the freelance sites showed me that they probably need a web developer to help them out. I kept encountering bugs on Upwork preventing me from setting up my account properly. Go figure!

But besides that, almost all the listings were for WordPress sites. It seems to me that WordPress and by extension PHP are still big for freelance development. I’m still not sure if I want to get into freelancing yet, but I think it’s possible to make a career for yourself if you take the time to learn PHP, WordPress, and get good at the basics of HTML/CSS/JavaScript. The other lesson here is that programmer memes and forums aren’t necessarily a good indicator of the actual development need that exists. That isn’t to say new and hot ___ are bad or not worth learning, but it’s probably good to understand why you’re learning a stack and what your goals are. You might end up not even coding very much and building websites in Squarespace, but sometimes that’s what people need!

Whenever I don’t have a project, I tend to solve small problems on Codewars. Here’s my profile for reference. It helps keep me in shape to do a few 8-6 kyu problems. They don’t teach you how to build a project, but they do keep you thinking about code and programming logic. I solved a few Leetcode problems too, which was fun! I realized I needed to understand algorithms and data structures to solve them, however, which leads me to my next point.

I picked up the book A Common-Sense Guide to Data Structures and Algorithms, and went through the early chapters. I’m still working on it, there’s a lot to learn in the world of computer science. I learned a lot about performance and a few ways to refactor/change code to avoid O(N^2) when you can turn it into an O(N), etc. I still need to finish the book, but it did help my understanding about the ways in which algorithms are used to solve everyday problems that are abstracted from us via libraries or the language itself. For example, a linter might use a stack to analyze your code for errors. I probably wouldn’t build a linter, but knowing how they built them is interesting! It’s a method for organizing information in a logical pattern—isn’t that all data structures and algorithms

This section will be short because I only learned a little Python for building an Excel script and for some browser automation for work. If you know Ruby, then Python is really easy to learn. They’re pretty similar, but Python has better Windows support and more popular libraries.

Overall, it’s nice to know that I could go into Python code and generally know what’s going on, considering its popularity. I might use it for simple coding problems on Codewars, as I typically use Ruby for those.

This is a crazy framework, because it’s often recommended by software engineers, but you rarely see any beginners talking about it (joking, of course). I started coding more on paper, and it’s been helpful for organizing my thoughts. I’m starting to plan ahead more rather than jumping into code. The lesson here is that project management and idea generation are integral to the software development cycle, and that’s why it’s a cycle. Git commits don’t always show the whole story.

A lot of developers seem to be picking Rust up. Companies like Microsoft and Google are switching codebases to Rust. But is it worth the hype for someone inexperienced like me?

The answer is a resounding yes! I picked up The Rust Programming Language, 2nd Edition, and have been reading through it. It illuminated a lot of concepts that were previously abstract to me. For example, I never understood pointers, references, and understanding these made it clear that the languages I’ve used up until now abstracted a lot for me. That isn’t necessarily a bad thing, especially for a beginner, but learning Rust had me trying to figure out how other languages like Ruby handle memory (garbage collector) and how the garbage collector works. To add to that, knowing the types of Rust forces you to be very explicit about the size of the numbers you’re using. If you need a conversion, you need to be explicit.

While it’s probably overkill for small projects, I feel like I understand how machines read code and how memory relates to performance in a way I didn’t before.

But this goes back to the lesson I mentioned in the game development section. Now I need to decide WHAT to make with the tools I have, which is more important than the tools I use. 

I’ll continue working with Rust and see if I can convert a few of my projects into it. I’ll also give WASM web development a shot eventually.

My year of exploration didn’t put a lot of commits into my GitHub. Many of these projects were started, unfinished, not committed, and then eventually deleted. In a sense, you could call it a year of failure. But that’s not what the intermediate plateau is about, in my opinion. You need to cover a lot of ground and make mistakes before you can move up and out of the long, flat plateau. It took a long time for me to improve as an artist once I “graduated” from beginner sketching, but now my drawings are significantly better. I had to bounce around a lot and try different mediums before things started to come together. But once you’re past that level, you now need to start making. While you can make simple projects all day every day, you'll probably want to make something more substantial.

That’s where I am now. I think 2024 will be a promising year for my software development. I have better development habits. I’m much better at picking up languages and frameworks quickly (finding the important parts and the similarities to what I currently know), better at planning and drafting up code before diving right in, better at debugging and testing, better at understanding how computers work, better at thinking about algorithms and data structures, better at reading other people’s code, and better at reading documentation.  All of these skills are essential to being an advanced developer, and I don’t think a tutorial could’ve given me these skills. I have a much better idea of where to go from here, and I’ll take all these lessons forward into new projects in 2024! Get stoked!