The bare necessities
People learn C# for many reasons. One popular use of the programming language is to make games with Unity. Regardless of what your plans are, it’s important to make your first resource a great one so that you can build off a strong foundation. Many resources are tied to a game engine, but this has the major disadvantage of splitting up the focus of the curriculum onto things like the engine’s user-interface and tools. For this review, I will be looking at a course with solely a programming focus, Learn How To Code Using C#: The Basics of Programming. Here are my thoughts.
About the Author
David Nixon is a software developer and indie game developer with an academic background in Computer Science. With an expertise in both web and game development, Nixon has gone on to author two courses, the other being an intro to Unreal Engine 4. Nixon was kind enough to provide me with access to this course.
Curriculum
- Flow Control (Boolean logic, iteration…)
- Methods
- Data Types
- Object-Oriented-Programming (constructor, public vs. private, inheritance…)
- Debugging and Error Handling
- Advanced Concepts (interface, generics…)
About the Course
This introductory course promises the inexperienced developer a fast-track to learning C# from the basics to more advanced topics such as interfaces and generics. It’s a bold promise that I assumed might be difficult to fulfil, especially given its short length (4 hours of lecture). After completing this brief course I have confirmed my fear: it is not enough.
Yes, everything that one would expect from an introductory course is here: theory discussion, examples, quizzes to help with review, and an abundance of exercises to challenge comprehension, but the author fails to deliver an engaging curriculum from start to end. Of the few areas that deserve praise, the most major is in its delivery of accurate information that gives a mostly passable explanation.
Those with a background in programming will feel somewhat comfortable taking the course; however, I predict inexperienced individuals will likely feel like they aren’t getting enough depth. I’d place this on the fact that all lectures simply feel like review. Both theory and practical application are taught at the same time. Instead of giving theory its fair share and then moving on to practical examples, the author cuts corners by simply opening some example file and walking through the entire thing while explaining what’s happening at each step.
Those with a background in programming will feel somewhat comfortable taking the course; however, I predict inexperienced individuals will likely feel like they aren’t getting enough depth.
There is no hint of visual editing at any point in the course. No highlighting tools (the author instead uses the mouse to highlight), no zooming in to make code more easily read (this is made doubly difficult by the fact that the course only comes in 720p). All lectures provide just enough information about a concept to meet the bare minimum requirement to consider them passable. The entire course is simply so rushed that it feels like one big review session. At no point in the course did I truly feel like I was being engaged. It became a chore to finish each video, especially given the awkward, clumsy pacing the course continually falls in to. There is a slightly noticeable improvement in pacing moving forward with each section; however, it just was never enough to occupy my full attention. While the slow pacing might have benefited beginners, the real issue is that the lectures feel too scripted and unpolished. Usually if an author is too slow I would speed up a video, but I just couldn’t find a playback speed where I felt comfortable. The subtitles (English only) did, however, improve the overall experience. It is always refreshing to find a course that put in the extra effort in creating subs with 100% accuracy.
Course visuals meet the bare minimum. There is no zooming to make reading code easier, no highlight tools, everything is 720p, and the course is 100% desktop screen-sharing.
One of the author’s strengths lies in his ability to keep lectures at just the right amount of focus. If a new concept comes up while still teaching, Nixon makes a small note but keeps things moving forward. I really liked the way he took time to point out common mistakes beginners make (e.g., accessing variables before declaration). I had mixed feelings about the advanced section. It was done as well or better than the beginner section of the course; however, it divides the curriculum and takes away some necessary time from the beginner section. It does, however, do a good job at easing beginners into more complex concepts and shows them what’s next. One of the few areas the author put extra effort into was showing solutions live rather than simply uploading the source code. Beginners should find this especially valuable.
“One of the author’s strengths lies in his ability to keep lectures at just the right amount of focus.”
While everything promised is in fact taught. The lack of effort put into the course, overall, simply won’t have students learning at their full potential. Often, the author is clicking around in Visual Studio while talking about something else. There could have been a lot more repetition for things like hotkeys and other beginner-targeted instructions. Moreover, by not having theory slides and only screen-sharing the author has really done the minimum required in order to call this a programming course. Just a few slides per lecture to cover theory would have helped so much at easing beginners in before jumping straight into coding examples. Ultimately, whether this style works for you will come down to how much experience you have with programming.
Summary
Despite it’s numerous flaws, Learn How To Code Using C#: The Basics of Programming manages to pull up its sleeves and deliver just barely enough to consider it a passable C# introduction. Although there is something to be gained from completing this course, an awkward pacing, lacking theory coverage, and poor visuals left me feeling not very engaged and it was thus a struggle to finish. Despite the promise to deliver to the inexperienced, those with at least somewhat of a programming background will likely find it more suitable. This course is more well suited for someone who has learned C# in the past (or a similar language) and is looking for nothing more than a refresher.
Pros
- Author shows a good degree of programming knowledge
- Great use of “gotchas” (common mistakes for beginners)
- Exercise solutions shown live
- Author maintains focus (doesn’t get sidetracked)
Cons
- Author’s lack of ability to engage
- Awkward, clumsy pacing
- Low quality video (720p)
- Complete lack of visual editing
- Not enough theory focus to help beginners understand concepts
Links
Get the Course – Course Link
More from the author – Link
ROTN 