This Week’s Programming Lesson: C# Start with Hello World

If you are brand new to programming, or maybe you've played around with code but never really learned C#, this week's programming lesson is going to seem almost ridiculously simple.

We're going to write Hello World.

Sure, if you have toyed with any programming, you have done this exercise. This one is particularly useful in C#. If you do this to start, you will never have to find out why it is such a valuable in C#.

For the next seven days, the exercise is to sit down for a few minutes and write a tiny C# program roughly 10 times per day. We're not building an application. We're not connecting to a database. We’re not learning APIs, classes, inheritance, or any of the more advanced stuff yet.

The goal this week is repetition and building a foundation of C#.

And just trust me, there's a reason for that.

Why Start This Simple?

One of the biggest mistakes I think people make when learning programming is trying to understand everything at the same time. You see a block of C# and immediately start wondering what every brace means, why there's a semicolon there, what a namespace is, and about 40 other things.

You don't need all of that on day one through 7.

It is key to get every step down and commit it to memory of mind and memory of fingers before moving on. So we need to get comfortable typing C# before we start worrying about understanding all of C#.

Your first program is about as simple as it gets:

Console.WriteLine("Hello, World!");

Now delete it and write it again.

The important part is that you actually type it. Don't copy and paste it ten times. We're trying to build some familiarity with what C# looks and feels like.

Let's Add One More Thing

Once you've written the basic version a few times, we're going to introduce one more concept: a function.

Write this:

SayHello();

void SayHello()
{
    Console.WriteLine("Hello, World!");
}

So why did we just turn one line of code into several?

Because now you're beginning to learn one of the most important ideas in programming: putting code somewhere and calling it when you need it.

For now, don't get buried in terminology. This:


void SayHello()
{
    Console.WriteLine("Hello, World!");
}

creates our SayHello function.

And this:

SayHello();

Calls it.

That's all I really care about you understanding this week.

You're going to learn plenty more about functions and methods later. Right now I want you to see that SayHello(); causes the code inside SayHello to run.

Then I want you to mess with it.

Change Stuff and See What Happens

This is another part of learning programming that I think gets overlooked.

Screw around with your code.

Change the message:

SayHello();

void SayHello()
{
    Console.WriteLine("I'm learning C#!");
}

Change the function name:

Welcome();

void Welcome()
{
    Console.WriteLine("Hello, World!");
}

Change the words. Make another function. Delete a semicolon and see what Visual Studio complains about. Spell WriteLine wrong. Forget a parenthesis.

Then fix it.

You're not going to hurt anything.

In fact, breaking your own code and figuring out what you broke is one of the best ways to start learning how programming actually works.

But, no matter what, write the whole thing 10 times per day.

And FYI, the error messages probably won't make much sense yet. That's okay. We're not trying to become experts at debugging this week either. We're just starting to recognize what working C# looks like and what happens when something isn't right.

Why 10 Times a Day?

Ten isn't some magical number. You don't fail the lesson because you only did eight one day.

The idea is simply to get enough repetition that the syntax starts becoming familiar.

If you write one Hello World program today and then don't touch C# again until next week, you're probably going to spend the first few minutes trying to remember how to do it again.

Instead, we're going to hammer the basics.

Ten tiny programs per day for seven days is roughly 70 repetitions. They might only take a minute or two each, but by the end of the week you should have it committed to memory. With any luck, you've forgotten semicolons, misplaced braces, spelled something wrong, fixed it, and run the program a few times.

Eventually, you stop having to think about every character.

That frees your brain up for the stuff we're going to learn next.

Don't Copy and Paste

This might be the only real rule for the exercise.

Don't copy and paste the code.

Type it in Visual Studio, VSCode, or hell even NotePad.

Then type it again.

Eventually, try doing it without looking at the example at all.

That's when you'll start noticing that something has changed. You'll be starting to recognize the structure.

That's It for This Week

I'm intentionally not adding anything else.

There's always a temptation when teaching programming to say, "Well, while we're here, let's talk about variables." Then variables turn into data types, which turn into user input, which turns into conditional logic, and suddenly our first lesson is 4,000 words long.

Nope. It might get boring but trust me.

That's the goal.

Because next week's lesson is where we can actually start making the computer do something with information you give it.

This Week’s Programming Lesson: C# Lesson 1