Initial Thoughts on C#

Having just started the second half of the curriculum here at Nashville Software School, I am neck deep in C#. It’s been a very humbling reminder of my initial feelings three months ago with JavaScript, when I had just started NSS and was desperately trying to master the syntax and possibilities for my first programming language. But that reminder is encouraging, seeing how far I’ve come in a short three months, I’m confident that I can do it again with this new language, and potentially accomplish even more. In the meantime, I’ve found it surprisingly refreshing to take a break from my C# studies by working on some side projects I had started in JavaScript, where I actually know my around (enough).

The biggest shock to my system thus far with C# has been static typing. In JavaScript I rarely had to think about what type of data a variable would hold when I created it. That was convenient at times, but also turn into a breeding ground for bugs. Not explicitly declaring types also made it that much harder for other engineers to digest my code, resulting in more comments or even longer variable names. Working through challenges in C# that I never even had to consider in my front-end life has been a rewarding experience, and I’m even starting to carry some of those explicit principles through to my JavaScript code. While jarring at first, I’m learning to find comfort and elegance in explicit typing.

Speaking of types, there are so many! I’m fortunate to have an instructor team to guide me through the jungle here, working through use cases for certain types and explaining why others have been deprecated or are not applicable to certain situations. I also gained some enlightenment by working through Cory Foy’s koans repo, which helped understand–among other things–the intricacies of Array’s and why we rarely use them.

Also finally had a proper introduction to Test Driven Development, which, at first glance, seems far more straightforward to execute in C# than in the front-end applications we had been developing. Funny side note, I attended a JavaScript meetup just last night and heard an excellent talk from Jonathan Boston that–among other things–inspired me to write front-end code that can be easily tested without browser automation. Anyway, I’m looking forward to starting a project with TDD in mind. If done properly, bugs can be identified almost as soon as they’re created, and you have an explicit jumping off point for debugging. Previously, I could have created a bug without knowing it, and by the time it reared its ugly head, I’ve already written another thousand lines of code and have a heck of a time reverting back.

We’ve also spent a lot of time as a class discussing higher-level programming concepts. I really enjoy stretching my brain with theory, and have a bit of experience from college and my past career that I can apply to concepts like Entity Relationship Models and data structure. I’m excited to dig deeper into database languages like NoSQL and finally put together the complete picture of a full-stack application.

Tomorrow we’re going to work through building our own API. It’s crazy to think that we’re at this point after just a week of learning the syntax and philosophies of C#, but that’s encouraging more than anything else. Hopefully the other languages I plan to dig into over the next few months will get easier and easier the more I have under my belt.

Until next time, thanks for reading!


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s