Chapter 1: Beginning of Linux.
Most people who don't care about technology might think
Windows is popular and "BIGGER," but here's the thing: 97% of the
world's top servers run on Linux. Your washing machine, car, flights, metro
system, traffic lights, satellites, smartwatch, even your phone, everything
depends on Linux. And if you're using Windows or iOS, chances are the
underlying hardware is running Linux based firmware anyway.
The story goes back to 1970. Dennis Ritchie, who also
created the C language (basically the foundation of most programming
languages), indirectly helped build Unix. Unix was incredibly powerful but also
incredibly expensive and closed-source. Only scientists and big institutions
could afford it, which is exactly why Linus Torvalds decided to create his own
Unix-like alternative.
It all kicked off in 1991. Torvalds was just a university
student when he posted about this small personal project on an online mailing
list, calling it a free kernel he made "just for fun." That was
Linux. Fast forward thirty years, and Linux now runs most of the world's
servers, nearly all supercomputers, the biggest cloud platforms, and billions
of devices through Android. Not many technologies have grown this big while
staying this quiet.
Timing played a huge role in Linux's popularity. Back in the
early 90s, Unix was powerful but locked down and expensive. Linux came along
offering similar capabilities, POSIX compatibility, and full source code
access, right when developers and researchers desperately needed freedom over
fancy features. Universities, research labs, and the first internet companies
jumped on Linux. Not because it was polished or easy, but because it was open
and actually worked.
When the internet started growing fast, Linux became the
obvious pick for servers. The networking features improved quickly and could
handle serious TCP/IP traffic. Early web servers, DNS systems, and mail servers
all relied on Linux because it just stayed online. Nobody cared what it looked
like. Uptime was everything, and Linux delivered.
Technically, Linux was built to be modular from day one. You
could develop device drivers, filesystems, and kernel pieces separately and
load them on the fly. Because of this, Linux became super flexible. It could
run on anything, a tiny embedded chip in your router or a giant server farm.
Now it works with more hardware platforms than you can count: x86 processors,
ARM chips in phones, the new RISC-V architecture, and even those ancient
mainframe computers that banks still use.
Here's where it gets interesting. Linux by itself was only a
kernel, it couldn't do much alone. Think about it, to actually use a computer
you need compilers to build programs, text editors to write code, shells to
interact with the system, and tons of other basic stuff. Richard Stallman's GNU
project had already built most of these pieces, but they were missing the
kernel part. Linux filled that gap perfectly. Put them together and you've got
yourself a real, functioning operating system.
Security wasn't added as a patch for later, it was in the
core of Linux. Linux took Unix security ideas like multi-user support, strict
permissions, and process isolation, then expanded on them. Features like
mandatory access controls, namespaces, and cgroups came later and became the
backbone of container tech. A lot of the security mechanisms in modern cloud
setups exist because Linux already had them at the kernel level.
Privacy and freedom is core feature of linux operating
system. it gives complete freedom to rice linux and build it yourself.
Linux also changed how people develop software. Most of the
tools developers use every day got their start on Linux. Version control, build
systems, compilers, package managers, all that stuff matured there first.
legend, Torvalds himself built Git just to manage Linux development, and look
at it now, every developer on the planet uses it. When your development tools
and your OS evolve together like that, it makes sense that Linux became the
default for real development work.
Cloud computing came along, and guess what? Linux didn't
need to reinvent itself. Stuff like KVM for virtualization just slotted into
the kernel. Containers? They were built using features Linux already had, no
need for complicated new layers. Kubernetes and all those orchestration tools
just use what Linux provides for managing resources. Basically, the cloud is
just Linux scaled up massively.
The community-driven model kept Linux alive and evolving.
Thousands of people across different industries review code, report bugs, and
boost performance. This kind of peer review means bugs get fixed fast and the
system stays stable long-term. Plus, it stops Linux from being controlled by
just one company's agenda or following temporary fads.
Linux doesn't try to be pretty or make everything simple for
casual users. It focuses on being correct, transparent, and giving you control.
Those qualities aren't flashy, but they're critical for the systems handling
global communication, commerce, and computing.
So, years later, Linux is still dominating. Not because
people are lazy or stuck with what they know, but because it actually keeps up.
Whatever new challenge computing faces, Linux adapts. It evolves without
breaking what works. It adds features without compromising stability. That's
why Linux isn't just a kernal or operating system, it's literally running
everything that matters in our digital world. Major respect to Linus Torvalds
for pulling this off.
(NEXT) Chapter 2: Story of Linux and Open-Source Stuffs.
waiting for next one
ReplyDelete