A preface regarding accompanied exercises

Say goodbye to the 100th „To-Do app“ exercises

Don’t you just hate it, when your programming teacher or mentor just bothers you with those typical and boring tasks everyone uses? I mean it’s the same repeating stuff over and over, nothing really original or „higher aiming“. I’m thinking of the typical things like for example the following here:

• Do an if / else here
• Create a loop xyz there
• Let’s create a To-Do app
• etc.

Yes? That’s what grinded my gears as a student like 15 years ago as well, so I fully understand you here. Keep in mind though, that you should have „the basics“ fully integrated in your developer brain, before you fight with (most of) the projects and tasks in my „accompanied exercises“ series.

Welcome to your journey towards „real projects“

If you can partially (or even fully) agree on those aspects from above, then let’s head towards a different approach. Being a programming mentor myself, I’m trying to teach software development to my students with a different way of learning. Don’t get me wrong, every dev journey will probably start with typical things like „how does an if statement work“, but then there should be a point where you actually move on.

I mean, you should really get to a point (learning resources focused) where you actually learn to use those things you’ve learned in a more „real“ project. Using the if statement like „Is that string a ‚yes'“ is probably one of the most boring things you could come up with – at least if you’re past that total beginner stuff. There will be a time where you’re actually craving like „now lemme use that damn stuff already“.

Subjects should – of course – match your actual learning progress. The best way to learn is having topics being slightly above your current knowledge state. Sadly this isn’t possible everytime, because there will be many scenarios where topics will overlap and you can’t just rip away one or the other. Right there I’m coming into play, a teacher or mentor supporting you live and who is able to adjust the learning process to your needs at any time. No stuff carved in like stone where you feel totally lost and alone!

You will fail, but it’s a part of the progress

I’m sure that this isn’t the best way to „promote“ my things, but in the end, I rather speak the truth than building up a bunch of totally unrealistic expectations from the „get go“, right!? Marketing isn’t everything, it’s more about the satisfied customers in my opinion, because they will speak for themselves, but enough of that.

Let’s now talk serious business and get back to my point, you will (a 100%, not only potentially):

• fail (here and there)
• hang (on stuff, you think you already „know“)
• throw the stuff to the side
• question yourself if you learned like anything
• forget (things you were already familiar with – partially)
• succeed (and get boosts of dopamine and euphoria)

Then, the whole cycle probably repeats itself over and over again – welcome to programming! Let me catch you right there: It’s all part of the progress – trust me!

I mean, I did fail and sometimes I still do nowadays – we all did and still do! The thing is, it’s no problem at all. We aren’t robots (maybe yet :D) and thus we’re prone to fail. Just relax, take a step back and try it again. Visualize by doing some sketches, talk about stuff with your friends, your colleagues or discuss on the internet. One important thing is: Step a way for a moment and sometimes even some days – mostly it will „click“ then.

Sure, with enough practice you will fail way less often, but only if you do exactly this:

• practice
• practice
• practice

Preparations & getting you started

Every house can be as beautiful as you wish or you could imagine, but it doesn’t help if you don’t have a strong foundation. The house will crash and / or get damaged through the instable base below itself. This counts for you – trying / doing my accompanied exercises – as well.

Of course I will try my very best describing and guiding you as good as possible, but the result depends on different factors. Next to preparations, it’s actually very important how you approach the exercises, as well!

The most important factor

The first important factor will be your already acquired base knowledge about programming or – for sure – especially C# / VB.NET. Usually my accompanied exercises – therefore the naming – are used in my programming lessons, where I would help and guide alongside it. However I decided to make them publically available for everyone – just don’t claim them as like yours or sell them, etc. You are allowed to use them for personal and commercial free, educational purposes.

Other factors – when learning programming – are like situational ones, meaning the kind of things you can prepare everytime you start studying. I’m talking for example about the following things listed right below.

Stay hydrated

Yeah, I already hear you! Even if I can’t see you nor I would be able to physically listen to you, I can hear you screaming in front of your screen: „I KNOW THAT I SHOULD DRINK ENOUGH!“. However you might be able to explain to me, why 80% of my students still forget having something to drink ready while studying with me then. In the end: You should get enough to drink before you (or we together in my lessons) get started studying. Of course, your drink of choice should be healthy like clean, usual water and like 500ml – without carbonic acid.

Don’t use autocomplete

As tempting as it is, one of the biggest problems of my students is actually using the different autocomplete options offered by the Visual Studio IDE. Especially nowadays, where some of the editors implemented some sort of AI based autocompletion. You probably ask yourself: „Why would a helpful feature could actually be against my learning process?“. It’s pretty easy! The most important thing you need – especially as a beginner – is practice and routine!

You can’t like learn to create correct constructors, if you use the autocomplete function which takes your brain away from the thinking process like: „Why do I need to express parameter a or b here, etc.“. And that’s just one of like twenty examples… Sometimes I decide or discuss with the individual student, because in some cases I would say: „Hey, don’t bother about writing a correct event handler out of your memory right now“.

Then there can be other cases, where I would recommend like: „Hmm, I would recommend focusing on learning to write xy out of memory, because you can focus on the actual programming problem instead of how you write xy“. Again, this depends on the individual person or his / her skills, personal preferences, etc.

Focus on the important stuff

As humans – and maybe especially as developers in the making – we love to know potentially anything about what we are doing like right now. Please do yourself a favor – and I can’t stress this enough – and don’t strive for knowing and deeply understanding everything when you’re studying something or in general, because you can’t! Especially at your (potentially) current knowledge level, things will come piece by piece!

I mean, I actually think no developer will reach a state where he knows like „everything“, but the overall knowledge grows and he’s (or she’s…) therefore able to solve different cases. Sometimes you instantly know the solution for a specific problem, sometimes it’s a little more problematic and there will be some cases as well, where you have to think for hours or days.

During my mentoring lessons, I will teach and tell you anyways, when you should prefer to focus on specific things! For this, I will take your current skill level into that suggestion, because it depends on you as the person itself. Of course, I can’t do this individually while you’re doing the accompanied exercises on your own. So don’t get to hard on yourself when you’re facing and maybe struggling on those!

Practice and grow your knowledge base

I know, that this factor kinda sounds like the „you need basic knowledge“ listed above, but wait a second. Lemme give you an example on this: Imagine some studying person, who actually knows (or at least he / she thinks) what properties – considering object oriented programming – are for. He then suddenly faces these properties in a more „real“ project, like my „Monopoly game clone“ exercise or my „RPG example“. I can see pretty often, that persons then suddenly lose like every knowledge about exactly those things they already „learned“.

People suddenly forget that you create properties like for storing „a state“ / „states“ on a container-like object. You can only decrease the occurences of these situations by improving and – first and foremost – consolidating your existing knowledge. In the end – I think – you can’t completely avoid these situations, but you can at least try to decrease the amount of times they are happening.

Actually read the exercise

I got you, you will most likely be like: „Of course I’ll read the exercise, seriously?“ now, but wait – again! It’s nothing new that our brain is like programmed (pun intended) to try to find some shortcuts here and there, but sometimes there are none! Actually, sometimes there are even bad ones, who will slow down you in learning programming. Instead of straight „jumping-to-action“, I would (really) encourage you to carefully read the tasks.

Let’s look at an actual example regarding a task from my accompanied exercise titled like „Monopoly game clone“. Of course, there needs to be some „bla bla“ around the actual task – because this is basically how customer interaction works –, but it’s always kinda highlighted. Customers won’t tell you „I need xy“ perfectly planned and structured right away, you need to learn, to read „between the lines“. I think it would be pretty boring otherwise, so here’s the example task:

…Now I feel like taking care of the start somehow. To find out who starts, each player usually has to roll the dice once. The one with the highest number of points wins! But how do you want to roll a dice without a dice? Now teach the program what a dice is…

accompanied exercise „Monopoly game clone“

As you can see, the focus is on that little sentence „Now teach the program what a dice is.„. Sounds complicated? It actually isn’t! Of course I could just tell you to „create a class“, but this way you wouldn’t know the ever occuring back story: Teaching your program what „xy“ is or – in other words – „When I need to tell my program, what a dice is, then I’ll take a look, if there is already a class for that provided by the .NET framework. If there isn’t, I can create my own class and tell the program that way.“

Look at this example code, this way we tell the program „this is a dice“:

public class Dice
{

}

Public Class Dice

End Class

C# and VB.NET know basic stuff like „that’s a string“ and „that’s a number“, but they don’t know what a „dice“ is. This way you will learn: „If I need to teach my program something what doesn’t exist (yet), I can introduce it (the new datatype) by creating a new class“ – boom!

How does it get rolled? Does the player roll it? It doesn’t roll itself, right? Do we need to implement some sort of physics? Actually, you shouldn’t care about this right in that moment: The task stated the marked stuff, nothing more!

How you should approach the exercises

In the last step, we’ve talked about some preparation steps you can do, to improve or positively affect your exercising experience, before it has actually started. We will now talk about how you should approach the tasks inside of the exercises and like what to expect / not to expect – especially from yourself ;)!

Solving tasks

When it comes to tasks in my accompanied exercises, you will see them „marked“ inside of a sub-headline starting with something like „Task – „. I purposely didn’t number them through, even though I did at first. But after many students trying those tasks, it was rather confusing when the order changed or when I improved something. In the end, I just stuck with that prefix instead.

Tasks themselves will of course have some sort of description, but not like „do this, do that“ only! They will describe and linearly guide from A to B, where I will try to exactly portrait the problem we’re trying to solve there. The exact „do xy“ part will be highlighted bold, just like this sentence here. So you will exactly know, what you should be doing in the end.

Please focus on the bolded parts (if possible) one after another. Read the complete section once, then pick one bold part, solve it, then go to the next. Don’t try to load everything into your brain at once and try to go slowly!

What if I can’t solve a task?

Well, you will a 100% run into situations, where you can’t solve the problem (at first)! I mean at least when you expect yourself to always finish a task within a few seconds and like always instantly know „the answer“. But as already mentioned in the section from above: You will hang, fail, etc.

In the end, this is no problem, as I’m trying to have you always guided here. You can always view the solutions by pressing the „Show solution“ button I’ve provided:

But please, do yourself a favor and don’t rush to the solution too fast! This won’t help you in any way and you WILL block your own progress!

There’s no 100%

Let’s talk business: While doing these exercises – as obviously someone who wants to practice –, don’t expect yourself to flawlessly finish the tasks without any stutters. They are meant to train your abilities, especially considering object modeling and designing program flows. This will – most likely – will a 100% bring you to stutters and sometimes even longer pauses for like some hours or day, etc. If this happens, step back, visualize (with sketches – who does what, etc.), take a pause like going for a walk with your dog and similar things.

The end isn’t your goal

Exercising isn’t done to reach a specific „goal“ like „finishing Monopoly“ in the first place. The main goal of these exercises is the progress and work itself – think of it like: „the journey is the reward“. I mean, sure, it’s nice to have a working (console) game in the end and you can of course get there, but the things you achieve while doing these exercises, lead to memories & experience sticking in your head – this is the key.

Repetitive stuff is annoying, right? No!

While doing the tasks, you will hear the same or pretty similar phrases very often! It’s no bug, it’s actually a feature! I’m doing this to plant things into your head like: „When I encounter problem x, there’s a solution y“. Muscle memory will have it’s role as well, it can and will drastically improve your capabilities of solving problems.

Thoughts only exist till written down

Your thoughts while programming only exist as „thoughts“ while you’re actually thinking them, right? This is why it’s so (and I can’t stress this enough) important to create notes. Not only like „this is how I iterate over a list of objects“, but more like „Hmm, I had problem x and y here, I solved it doing z“ – just as an example!

Paraphrasing sucks

Yeah, we all know this problem… Especially as developer, it’s your job to hear your (soon to come) talking customers or work colleagues and pick the essential parts out of the „blabla“. Guess what – this is exactly why I’m trying to find the balance between: „This is strict task A, straight to the point“ and „<Insert description around the actual problem here>“ while formulating the tasks for you. I won’t strictly get to the point, but I will try to not talk too much gibberish going to far away from the point.

Progress isn’t linear

This aspect just moves along with the real world, just like the last section (and most of the others lol). When developing „real world“ projects, there isn’t always a stricly linear approach and solutions. You actually need to refactor portions of the code and change processes pretty often as well. So please don’t get confused when we’re changing stuff, we just created some tasks ago. If we notice, that something needs to be changed – we will do so!

Wrapping up

So in today’s blogpost we talked about my custom / newer approach of teaching programming students the world of programming – called „accompanied exercises“. You read about how you can (and potentially should) approach the programming exercises. Next to the „what you should do“ aspect, we’ve talked about the (at least) equally important aspect of „what not to do“, as well.

I would now encourage you to „just start“! Go ahead and find an accompanied exercise you would like to do and just start! Of course there will be more and more exercises coming, soon there will be at least 3. Take a look at the following links.

Related posts

• An overview of accompanied exercises (.NET – VB and C#)
• Building a Gaming Console (coming soon)
• Creating a Monopoly clone (coming soon)
• Making your own RPG like game (coming soon)