DEV Community: DevREML

Hello World!

DevREML — Sun, 01 Nov 2026 20:08:40 +0000

Writing “Hello World!" as your first program is a long tradition in programming. The earliest known example comes from Brian Kernighan who used a small program that printed “hello, world” in a tutorial for programming in 1972. This tradition became widely known through the book The C Programming Language by Brian Kernighan and Dennis Ritchie. And for good reason.

Hello World is a simple, yet powerful introduction to coding. It allows beginners to dip their toes into the world of programming and to see that the code that they write actually does something.

The source code

So, as tradition will have it, I did the same. In my IDE (I use Jetbrains Rider) I wrote the following line of code:

Console.WriteLine("Hello World!");

After running the command dotnet run ,or simply clicking the run button, the following output is displayed in the console:

Looks simple enough, right? Yet the question remained in my head: what exactly did I just write? What is Console.WriteLine? And how does the computer know that I want to display the text “Hello World!”?

It turns out that this single line of code contains more than it seems. Let’s break it down.

Just a note before we start

There are different versions of this code. Some tutorials and online resources show a longer version, like the example below:

using System;

namespace Daily_Commits
{
  class Program
    {
      static void Main(string[] args)
        {
          Console.WriteLine("Hello World!");
        }
    }
}

This version contains more lines of code: a using directive, a namespace , a class and a Main method. What is important for now is that both versions do exactly the same thing. Newer versions of C# allow you to leave out the surrounding code, because the compiler adds it behind the scenes. When you run the code, the output will be the same.

Then why do these extra lines exist? As we advance in our journey and our projects become bigger, this structure becomes more relevant. For now, the focus will lie on the line of code that actually produces the text, aka Console.WriteLine(“Hello World!”); Concepts like classes and directives will be named along the way, but only in relation to that line.

Console.WriteLine(“Hello World!”);

Our one line of code consist of different elements, each with its own role.

Console and WriteLine

Console and WriteLine are formally known as identifiers or informally as names. An identifier allows you to refer to some existing code element. I did not write the code behind Console or WriteLine myself. I am simply referring to code that already exists.

Although they are both identifiers, they are not the same. Console is a class, while WriteLine is a method.

Think of a class as an entity that solves a single problem or performs a specific job. The job of the Console class is to interact with the console window. Classes are primarily composed of two things: the data they need to do their job and the tasks they can perform.

Those tasks come in the form of methods and WriteLine is an example. A method is a named, reusable block of code that you can ask to run. The task of WriteLine is to take text and display it in the console window on its own line.

The Parentheses

Asking a method to run is called a method call or method invocation. This is done by placing a set of parentheses after the method name, which is why our code contains WriteLine(…)

Methods differ in what they need and what they give back. Some methods require data to perform their task, while others need none. Some methods return information when they finish, while others return nothing and simply do their job.

WriteLine belongs to the methods that do their job without returning anything. To display our text however, it does need input : it has to know what to display. This input is supplied by placing the text between the parentheses.

In our case, the input is "Hello World!". In programming, text is called a string. Our text is a literal string to be exact. A literal string is a value that is written directly in the code, exactly as it is.

The dot operator

Between Console and WriteLine there is a period ( . ). This is called the member access operator, or simply the dot operator.

Code elements in C# are organized hierarchically. Some code elements live inside other code elements, and are members of their container. For example, a class can have methods as members, but a method cannot have a class as a member. The dot operator allows us to dig down in this hierarchy, from class to method for example. Console.WriteLine therefore means: go to the Console class and within it, use the WriteLine method.

The Base Class Library

That leaves just one question. If I did not write Console and WriteLine myself, where do they come from?

Both are part of the Base Class Library (BCL). The Base Class Library is a large collection of ready-made code that comes with .NET. It contains many classes, each with many members, that every developer can use. It provides every C# program with a set of fundamental building blocks, so you don’t have to build everything from scratch.

To keep this enormous collection organized, the classes are grouped into namespaces. The Console class lives in the namespace System. This is also what the line using System; in the longer version refers to: it tells the compiler to look in the System namespace when it comes across a name like Console. Again, newer C# projects do this automatically, which is why our single code works without it.

The semicolon

Our line ends with a semicolon ( ; ). In C#, the semicolon marks the end of a statement, much like a period marks the end of a sentence. It tells the compiler that this instruction is complete. Forget it, and the compiler will let you know.

Compiling the code

Put together, our line of code is a complete instruction: use the WriteLine method of the Console class to display "Hello World!" in the console. This is our source code, written language that we as humans can read and understand.

The computer cannot run C# code itself. Its circuitry only runs low-level binary instructions formed out of ones and zeros. So before the computer can actually carry out our instruction, the source code must be transformed into something it can run. This transformation is called compiling and is done by a special program called a compiler.

In C# this happens in two steps. First the compiler takes our C# code and the configuration of our project checks whether the code follows the rules of the language, and translates it into an in-between language. This result is stored in a .dll file. Then, when we run the program, .NET translates this in-between language into the binary instructions that our specific computer can execute. Only then does "Hello World!" appear on the screen

And that’s it. If you made it through, I hope you now have a better understanding of what this one line of code actually does and I thank you for reading my article. Feel free to reach out to me on Linkedin.

Next week we will look further into the string we used. We will discuss data types and introduce the concept of variables.

References

RB Whitetaker, The C# Player’s guide, Level 3, fifth edition.
Microsoft Learn, “Console Class”: https://learn.microsoft.com/en-us/dotnet/api/system.console?view=net-10.0
Microsoft Learn, “Console.WriteLine Method”: https://learn.microsoft.com/en-us/dotnet/api/system.console.writeline?view=net-10.0
W3Schools, “C# Tutorial”: https://www.w3schools.com/cs/index.php
helloworlds.io, “Origins”: https://helloworlds.io/origins

What Is C#, Really? Breaking Down the Definition

DevREML — Fri, 25 Sep 2026 17:51:42 +0000

Before diving into syntax, tutorials, or your first "Hello, World," it's worth pausing on a more basic question: what exactly is the thing you're about to learn? Based on Microsoft Learn's documentation and additional reading, the following definition for C# emerges:

C# is a cross-platform, general-purpose programming language within the .NET platform.

Four terms in that sentence — programming language, cross-platform, general-purpose, and .NET platform — each carry specific meaning, and each answers a different part of the question "what am I actually learning?" This article breaks the definition down term by term, starting with the term programming language.

Programming language

Before addressing what kind of programming language C# is, it is worth establishing what a programming language is in the first place. A programming language is a system that allows a person to write instructions for a computer to carry out. Each language has its own syntax, but this is largely surface-level — after learning one programming language, the underlying concepts tend to transfer, which is why picking up a second or third language is generally faster than learning the first.

The core function of a programming language is translation of intent: it lets a human express what they want done in a form that is both human-readable and, eventually, machine-executable.

What a developer writes is referred to as source code. Machines, however, only operate on machine code — patterns of ones and zeros that produce a specific effect — so at the point of writing, source code can be read and modified by a person, but the computer cannot execute it directly yet. The step that bridges this gap is a piece of software called a compiler, which converts source code into machine code.

This compilation step is picked up in more detail in the .NET platform section below, since it is exactly what the .NET compiler is responsible for.

This is a useful starting point because it applies to any programming language, not just C#. It's the baseline the rest of the definition builds on top of.

General-purpose

The term general-purpose stands in contrast to domain-specific. A domain-specific language — SQL for querying databases, or CSS for styling web pages, for example — is built for one narrow task. A general-purpose language, by contrast, is designed to address a wide range of problems.

That range shows up clearly across C#'s actual application domains. For web development, ASP.NET Core supports everything from server-rendered pages built with Razor Pages or MVC to client-side UIs with Blazor, as well as web APIs for backend services. On the desktop, C# powers Windows-specific apps through WPF or Windows Forms, as well as cross-platform desktop apps via .NET MAUI — which also extends to mobile development, giving access to native device features like cameras and GPS. In the cloud, the Azure SDK for .NET, background services, and distributed-app tooling like Aspire support microservices and cloud-native applications. Games are another major domain, most notably through Unity, alongside MonoGame and CryEngine. C# even reaches into IoT, running on devices like the Raspberry Pi to read sensors and control hardware.

These six domains, each supported by an established toolchain, substantiate the "general-purpose" classification.

Cross-platform

Cross-platform addresses where the resulting solution can run. Compiled C# code can run on Windows, Linux, macOS, iOS, and Android. In other words, across multiple platforms.

The .NET platform (as an ecosystem)

The phrase "within the .NET platform" refers to an ecosystem: a combination of languages, a compiler, a runtime, a library of pre-built functionality, and supporting tools. Understanding this ecosystem means understanding several distinct pieces and how they relate to one another.

The language. C# (along with other .NET languages such as F#) is what a developer writes directly. Each line is an instruction, but it cannot be executed by the computer in this form.

The compiler. The C# compiler translates source code into Intermediate Language (IL) which is stored in a .NET assembly (a .dll or .exe file). Compiling to this intermediate format is what allows the same assembly to run across different operating systems and hardware architectures without modification.

The runtime. The .NET runtime is the execution environment that runs the compiled assembly, managing memory and executing instructions on the host operating system.

The Base Class Library (BCL). Beyond the compiler and runtime, .NET also ships with a large collection of ready-made, pre-tested code that a program can call on directly, known as the Base Class Library. Its purpose is to spare developers from re-implementing routine functionality themselves — opening a file, outputting text on the console or computing a square root, for instance, are already solved problems inside the BCL rather than something to write from scratch. In effect, a large share of the groundwork any given program needs has already been written and is simply waiting to be called on.

The SDK. .NET is distributed together with a Software Development Kit — a bundled set of tools (compiler, project templates, command-line utilities, and more) intended to make the day-to-day process of writing, building, and running programs more manageable.

Platform-specific tooling. On top of these general-purpose pieces, .NET also provides tooling aimed at specific categories of application — web, mobile, and desktop, among others — which is where frameworks like ASP.NET Core and .NET MAUI, mentioned earlier, actually originate.

Language family

Apart from definition, it is also good to point out that C# belongs to the same language family as C, C++, and Java. This has practical consequences: shared syntax conventions (curly braces, semicolons, similar control-flow structures) mean that developers with a background in Java or C++ typically find C# syntax familiar, and that learning C# can ease the path to learning related languages afterward.

Scope of the definition

A single-sentence definition doesn't tell us everything about C#. What it does offer is scope — a sense of what kind of thing is being learned, before the finer details come into focus. That makes it a solid starting point.

The next step is to see this in practice. In the next article, we'll dissect the piece of code nearly every developer writes first — "Hello, World" — and use it to make these abstractions concrete.

Many thanks for reading my post. Feel free to contact me via Linkedin: https://www.linkedin.com/in/raissa-limon-04154a330/

References

Microsoft Learn, "A tour of the C# language" — https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/overview
Microsoft Learn, "Introduction to .NET" — https://learn.microsoft.com/en-us/dotnet/core/introduction
Microsoft Learn, "What you can build with C#" — https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/what-you-can-build
R.B. Whitaker, The C# Player's Guide, 5th edition
Harvard CS50x 2025, Lecture 1 ("C"), section "Source Code"