Programming Languages

Python is a high-level programming language. People choose it because its simple and readable. 

You can anything with python.  

• Build things quickly. 

• Write a web server in a few lines of code.

• Manage Cloud Services together with Golang.

• Analyze massive datasets with pandas.

• Train machine learning models with TensorFlow.

• Automate boring tasks with simple scripts/Selenium. 

Assembly language is the closest programming language to machine code. 

You write instructions, like that image shows you, and they are translated straight to machine code by the Assembler. 

Each instruction does one small thing, like moving data, adding numbers, or comparing values.

Programmers use assembly when they need maximum control over hardware or want to make their code run as fast as possible. 

Go to the bitcoin, apache, source code on Github, and you will either find, C, C++ or ASM. 

Something like OpenJDK: https://github.com/openjdk/jdk 

or the Intense Cryptographic operations of veracrypt:
https://github.com/veracrypt/VeraCrypt

OSDev.org can teach you how to create an operating system, start with C/C++/Rust or any language of your choice, but at some point you will have to integrate with ASM i.e Inline ASM. 

Remember, when you open your computer, the programs running need to talk to the operating system, and the operating system talks back and forth with the hardware.

Windows API is the toolbox that lets programs talk to Windows that way.

An API is a middleman. When I tell you to open ChatGPT and send a request, there's a Web API in action that tells the server: 

"Here's Nick's request, do this or that."

Server responds and you are chatting with ChatGPT!🎉

On Windows, C and C++ are the original languages that use that toolbox directly—pure conversation between your program and the operating system. 

No translators, no middlemen. Just your code calling Windows functions like CreateWindowEx() and Windows doing exactly what you asked.

CreateWindowEx() creates a window/GUI as most call it. That means windows creates your app, the elements inside it, styling and size, then WNDCLASS and WNDPROC procedures do the coloring.

That's it. That's WinAPI with C/C++.

When you write Windows API code in C or C++, you're basically speaking Microsoft's native language. Your are telling the OS, 

"Do this, directly!😤Am in charge here! And windows has to respond..."

Every window you create, every button you draw, every file you open—you're making direct calls to the functions that Windows provides. 

WHY PEOPLE STILL DO USE WINAPI?

Some folks enjoy the control. When you call CreateWindowEx() in C, you know exactly what's happening: Windows allocates some memory, sets up data structures, and gives you back a handle to your new window. 

Classic Windows applications like Notepad , MS Word and Photoshop's early versions, were built this way. You got maximum performance and minimum bloat.

There's something satisfying about writing a complete Windows application in C that fits in a few 100kbs.

Check out simplewall which is a fully functional WinAPI programmed software. 

These days, a "hello world" in some frameworks can be 20mbs.

Writing raw WinAPI code feels like crafting something by hand in a world of 3D printers and AI Vibe Coding Slop.  

It's not always practical, but it teaches you how things actually work.

CAN WE USE OTHER LANGUAGES WITH WINAPI?

Yes! Here's How It Works:

I. RUST

call WinAPI, through its Foreign Function Interface, that lets it talk to C libraries. People have even created crates (Rust's word for libraries) that wrap Windows API functions with safe Rust interfaces.

So if you're a Rust fan(rustafarian)😂, you can still build Windows applications. 

II. C# 

Takes a different approach. Instead of calling WinAPI directly, C# usually works through .NET Framework or .NET Core, which provides its own set of classes for Windows programming. 

But the cool part is that C# can still call WinAPI functions directly if you need to. 

It's called P/Invoke (Platform Invocation), and it lets C# programs reach into Windows DLLs and grab whatever functions they need. 

Think of it as C# knocking on Windows's door and saying: 

"Hey, let me in, I brought a translator." 

Most C# developers don't bother because .NET gives them nicer ways to do the same things, but the option is there when you need it.

DO LANGUAGES HIDE WINAPI CALLS?

I. Python

Absolutely yes, and that's the whole point!

Languages like Python are masters at hiding complexity. When you write tkinter.Button(root, text="Click me") in Python, somewhere deep down, that Python code is eventually calling Windows API functions to create that button. 

But you never see it. You don't have to worry about window handles any of that messy stuff. 

It's like ordering a coffee by saying "the usual" instead of explaining how to grind beans and operate an espresso machine. The barista (Python.exe the software you install from Python.org) handles all that work for you.

When you run that tkinter script, the Python interpreter (python.exe) talks to a library called _tkinter, which talks to the Tcl/Tk engine, which finally makes the low-level Win32 API calls (like CreateWindowEx) that Windows understands. 

II. Java

Does the same thing. "Write once, run anywhere" means Java completely abstracts away the underlying operating system. 

Your Java code doesn't know or care whether it's running on Windows, Mac, or Linux—which means it's not calling WinAPI directly at all. 

It's calling the Java Virtual Machine, which then calls the operating system. 

It's like hiring a travel agent who handles all the local languages and customs so you don't have to.

III. JavaScript/Electron 

Takes hiding to another level. You write HTML, CSS, and JavaScript, and Electron packages that whole thing with a stripped-down Chrome browser into a desktop app. 

Underneath, Electron is calling WinAPI to create that window, but you're just writing web code. 

It's like ordering a pizza through a delivery app—you never talk to the chef, the oven, or the delivery guy. You just get pizza.

SO DO WE HAVE TO WORRY ABOUT WINDOWS API?

Here's the honest answer: it depends on what you're building.

I. Building a simple web app? 

Python, JavaScript, or Ruby will keep you far away from WinAPI, and that's wonderful. You've got better things to worry about.

II. Building a cross-platform desktop app? 

Electron, Flutter, Java, or Python with Tkinter/PyQt might be better choices—they handle the OS differences for you. 

You write once, they figure out whether to call WinAPI on Windows or Cocoa on Mac or X11 on Linux.

III. Building a high-performance Windows-only application? 

Knowing WinAPI gives you superpowers. You can optimize everything, debug weird issues, and understand why your program behaves the way it does.

Game developers, security researchers, and performance junkies live here.

III. Just curious how computers work? 

Learning a little WinAPI in C is like lifting the hood on a car. 

You might not become a mechanic, but you'll appreciate what's going on when you turn the key. 

Plus, it makes you look really smart at DEFCON.

IV. Writing and Reversing malware? 

(Not that you would... 😇) Malware authors love WinAPI because it lets them talk directly to Windows without all those fancy framework safety nets. But we don't do that here. cough.

V. The Bottom Line

Most modern developers rarely touch WinAPI directly. The languages and frameworks we use have built nice, comfortable layers on top of it. 

But underneath every Windows program—whether written in Python, C#, Rust, Java, or JavaScript—the WinAPI is still there, doing the real work.

Linux and macOS have their own versions of "WinAPI"—they're just called different things. 

On Linux, the main interface is POSIX (Portable Operating System Interface) and the system calls built into the Linux kernel. 

When you write C code on Linux, you're talking directly to the kernel through functions like fork(), open(), and socket(). 

On macOS, which is built on Unix (specifically BSD), you get a similar POSIX interface plus Apple's own Cocoa and Carbon frameworks for creating windows and handling macOS-specific stuff. 

So, while the names and specific functions change, the idea is the same: every operating system gives programmers a toolbox to talk to it. 

Windows calls it WinAPI.

Linux calls it system calls/POSIX. 

macOS calls it Cocoa/BSD. 

Different names, same concept.

These are three cousins in the programming world.

They're all compiled languages that care about performance, but each has its own personality.

Compiled means, C, C++ and Go, take the code you write, pass it to a compiler and produce a single file with all requirements inside it, as machine code. 

You can also write dlls if you don't want to have a massive program, but these languages mostly do single file executables. And you might end up in dll hell where your program can't run till you give it the goddamn missing dll!!😤

I. C is the wise grandparent. 

Born in the 1970s after Assembly Language and B-Language became too hard, it's simple, direct, and doesn't sugarcoat anything. 

You want to manage memory yourself? Go for it. 

You want to talk directly to hardware? 

It's the language that built the foundations of the modern internet—UNIX, Linux, Windows kernels—all written in C. 

It's not a fancy language with 10 billion frameworks like JavaScript, but it never lets you down.

II. C++ is C's ambitious Bro. 

It took everything C could do and said, 

"What if we could also model the world in objects?" 

"Let's add some few things here and there..."

So it added classes, inheritance, polymorphism and a billion ways to do one thing, while keeping all that low-level power. 

Game engines, browsers (like Chrome), and massive applications like Photoshop? Those are products that run on C++ engine. 

C++ is a language you can learn and use everywhere, from android operating system programming and reversing, to android app development, to windows, mac and linux programming. 

III. Go (often called Golang) is the young upstart. 

Google created it in 2007 because they felt existing languages made building large-scale systems too painful. 

Go takes the simplicity of C—clean syntax, fast compilation—and sprinkles in modern features like garbage collection (so you don't have to manage memory manually) and built-in concurrency (making it easy to do many things at once). 

It's what companies use when they need to build reliable, scalable systems without the headache. 

Docker, Kubernetes, and many cloud tools are written in Go.

IV. Why We shall study them over the coming years together? 

If you learn all three, you'll understand the evolution of systems programming. 

You'll see how we went from building operating systems (C) to building complex desktop applications (C++) to building cloud infrastructure (Go). Each one solved problems the previous one left behind.

And here's the fun part: once you know C, learning C++ feels like getting superpowers. 

And once you've battled with manual memory management in C/C++, learning Go feels like a vacation. They're a trilogy worth experiencing.

I will start with C programming, because its easier and has an "ending". 

C++ has no ending, you usually study what you need and leave the rest😂You will never master it.