Not much known to new Linux users is that Linux has had for many decades web
browsers that can be used directly in the terminal. In this post, let's learn
about Lynx, a great terminal application for Linux.
Lynx stands as one of the oldest web browsers still in use today, providing a
unique and efficient way to browse the web directly from the terminal.
Designed for speed and simplicity, Lynx is a text-based browser that allows
users to navigate web pages in a manner that is particularly beneficial for
users with limited bandwidth or those who prefer a distraction-free
interface.
Key Features
Speed and Performance
Lynx is lightweight and operates swiftly, particularly on older hardware or
over slow connections. Since it exclusively handles text, loading much faster
than graphical browsers is a significant advantage.
Keyboard Navigation
Designed for keyboard lovers, Lynx utilizes intuitive keyboard shortcuts for
navigation, making it a great choice for those who prefer not to use a mouse.
You can jump between links, scroll through pages, and execute commands
seamlessly with just your keyboard.
Accessibility
Lynx is not just for tech-savvy users; it's an accessible tool for anyone who
finds visual interfaces overwhelming. As a text-based browser, it is highly
usable for individuals with visual impairments, who might rely on screen
readers.
Customization
Users can easily configure Lynx to suit their needs. Settings related to
display, colors, and even configurations for specific websites can be
adjusted, making it a versatile option.
Security
Lynx presents a smaller attack surface compared to graphical browsers, which
can be subject to more vulnerabilities. The lack of JavaScript and other
executable content significantly reduces risks.
Installing Lynx on Linux
The installation process for Lynx is straightforward and typically can be done
via terminal commands. Here’s how you can install Lynx on various Linux
distributions:
Ubuntu/Debian
```bash
sudo apt update
sudo apt install lynx
```
Fedora/RHEL
```bash
sudo dnf install lynx
```
Arch Linux
```bash
sudo pacman -S lynx
```
OpenSUSE
sudo zypper install lynx
Basic Usage of Lynx
Lanching
After installation, you can launch Lynx by simply typing `lynx` in the
terminal.
Navigation
Navigating Lynx is simple but does require memorization of some key commands:
Arrow Keys: Use these to move up and down through links and content.
Enter: Opens the selected link.
B: Go back to the previous page.
G: Go to a specific URL.
Q: Quit Lynx.
H: Access Help to see all commands
Opening a Website
To open a website, simply type:
lynx https://www.example.com
Lynx will display the content in a readable format, with links clearly
indicated.
Why use browser based terminals?
Pros:
Lightweight and fast
Ideal for low-bandwidth usage
Simple keyboard navigation
More secure due to fewer features
Cons:
No graphical support
Limited to text-only content
Less user-friendly for beginners
Modern web features often unsupported
Conclusion
For users seeking a fast, efficient, and distraction-free browsing experience,
Lynx is a commendable choice. Its simplicity and speed can be
especially appealing in today’s world, where online bloat can slow down even
the most robust systems.
Despite not having graphical capabilities of modern browsers, Lynx has its
place in the toolkit of anyone looking for an alternative way to experience
the web.
Whether you’re a seasoned programmer, a terminal enthusiast, or simply someone
looking to reduce your online distractions, Lynx is worth exploring in your
Linux environment.
Wednesday, March 25, 2026
What is a Shell in Linux?
Learn what is a shell in Linux, your shortcut to a successful career with Linux and open source software
Commonly mentioned in the Linux (and systems administration) world is the word shell. But what is it?
A shell in the context of Linux is a user interface that allows users to
interact with the operating system. It provides a way to execute commands, run
programs, and manage files from a command-line interface (CLI) instead of a
graphical user interface (GUI).
Types of Shells
There are several types of shells available in Linux, each with its own
features. The most common are listed below.
Bash
The Bourne Again SHell, the default shell for many Linux distributions, known
for its rich feature set and scripting capabilities.
Zsh
Z Shell, an extended version of Bash with enhanced features such as improved
auto-completion and globbing.
Fish
Friendly Interactive SHell, designed for user-friendliness, with syntax
highlighting and automatic suggestions.
Tcsh
An enhanced version of the C shell (csh), offering command-line editing and
job control. |
Key Functions of a Shell
Let's review why a shell exists in the first place.
Command Execution
You can run commands to perform tasks such as file manipulation, program
execution, and system monitoring.
Scripting
Shells allow users to write scripts to automate repetitive tasks, making
system administration more efficient.
Environment Management
Users can set and manage environment variables, affecting how processes
behave.
Job Control
You can manage running processes, including background tasks and foreground
processes.
How to Access the Shell
So how does one access a shell in Linux?
Open the Terminal
You can typically find the terminal in the applications menu or by using a
shortcut like `Ctrl + Alt + T`, using the mouse (click on the terminal icon)
or in Gnome, press the Super key -> terminal to start it.
Command Line Interface
Once open, you will see a command prompt where you can type commands.
Basic Commands
Here are some basic commands everyone should know while using the shell.
ls Lists files and directories.
cd [directory]: Changes the current directory.
cp [source] [destination]: Copies files or directories.
mv [source] [destination]: Moves or renames files or directories.
rm [file]: Deletes files.
What to learn next
We recommend learning Bash next. Bash is the default shell in most Linux
distros, and also default on enterprise Linux distributions such as Ubuntu or
RHEL.
Conclusion
The shell is an essential component of Linux, giving users powerful
functionalities for interaction without needing a graphical interface.
Understanding how to use the shell can greatly enhance productivity and system
control. Whether you're a beginner or advanced user, getting comfortable with
the shell will improve your efficiency in managing a Linux environment.
Monday, March 2, 2026
Using WebDAV on Linux
Learn to use WebDAV, a networking tool to mount filesystems, a great option for collaborative environments
WebDAV (Web Distributed Authoring and Versioning) is an extension of the HTTP
protocol that facilitates collaborative editing and management of files on
remote web servers. It provides a framework for users to create, change, and
move documents on a server, enabling various functionalities crucial for web
collaboration.
Key Features
File Management
WebDAV allows users to manage files on a server, including creating, editing,
deleting, and moving files.
Collaborative Editing
Multiple users can edit the same document simultaneously, helping in teamwork
and collaboration.
Locking Mechanisms
To prevent conflicts, WebDAV supports file locking, which ensures that only
one user can edit a document at a time.
Metadata Support
Users can attach metadata to web resources, enhancing information
management.
Cross-Platform Compatibility
Compatible with various operating systems and applications, allowing seamless
integration.
Deploying WebDAV
So let's see how to deploy and use WebDAV
1. Install davfs2
Install from your package manager (in Ubuntu it's named
davfs2) or download the latest
version of davfs2 from
the
davfs2 download page.
2. Configure the davfs2.conf file.
Make sure the following properties in the file are configured as shown
below:if_match_bug 1 delay_upload 0 use_locks 0
3. Create the mount point.mkdir
$ sudo mkdir /mnt/dav
4. Mount a share in the dav directory on your server.
For example, to set up a WebDAV connection to dotcms.org at the mount point
/mnt/dav on your local host, use the following command:
mount -t davfs http://<IP>/webdav/live/1 /mnt/dav
You will then be prompted for your username and password which will give you
access to your WebDAV server.
Unmounting
You must manually unmount the WebDAV folders when you are finished:
$ sudo umount /mnt/dav
Common Use Cases
Content Management Systems (CMS)
WebDAV is often used in CMSs for file management and editing.
Cloud Storage Solutions
Many cloud storage services use WebDAV for file access and editing.
Version Control
WebDAV can be integrated with version control systems to manage document
versions effectively. Today, this would be more common to host documents
(think Word, Excel, etc) than to replace Git.
Conclusion
WebDAV enhances the capabilities of web servers by providing a structured way
to deal with resources, making it an essential tool for collaborative
environments.
Monday, February 23, 2026
Using the ip command in Linux
Why you have to stop using ifconfig and start using ip, the modern method for
configuring a Linux network interface.
For a long time, the ifconfig command was the default
method for configuring a network interface. It served Linux users
well, but networking is complex, and the commands to configure it
must be robust. The ip command is the new default
networking command for modern systems, and in this article, I'll
show you how to use it.
The ip command is functionally organized on two layers
of the
OSI networking stack: Layer 2 (data link layer) and Layer 3 (network or IP layer). It
does all the work in the old net-tools package.
The ip command is included in the
iproute2util package. It's probably already included in
your Linux distribution. If it's not, you can install it from your
distro's software repository.
Comparing ipconfig and ip usage
The ip and ipconfic commands can be used
to configure a network interface, but they do things differently.
I'll compare how to do common tasks with the old
(ipconfig) and new (ip) commands.
View network interface and IP address
If you want to see the IP address of a host or view network
interface information, the old ifconfig command,
with no arguments, provides a good summary:
The new ip command provides similar results, but
the command is ip address show, or just
ip a for short:
$ ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever 2: eth0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc pfifo_fast state DOWN group default qlen 1000
link/ether bc:ee:7b:5e:7d:d8 brd ff:ff:ff:ff:ff:ff 3: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether 08:71:90:81:1e:b5 brd ff:ff:ff:ff:ff:ff
inet 10.1.1.6/27 brd 10.1.1.31 scope global dynamic wlan0
valid_lft 83490sec preferred_lft 83490sec
inet6 fdb4:f58e:49f:4900:d46d:146b:b16:7212/64 scope global noprefixroute dynamic
valid_lft 6909sec preferred_lft 3309sec
inet6 fe80::8eb3:4bc0:7cbb:59e8/64 scope link
valid_lft forever preferred_lft forever
Add IP address
To add an IP address to an interface with ifconfig, the
command is:
$ ifconfig eth0 add 192.9.203.21
The command is similar for ip:
$ ip address add 192.9.203.21 dev eth0
Subcommands in ip can be shortened, so this command is
equally valid:
$ ip addr add 192.9.203.21 dev eth0
You can make it even shorter:
$ ip a add 192.9.203.21 dev eth0
Remove an IP address
The inverse of adding an IP address is to remove one.
With ifconfig, the syntax is:
$ ifconfig eth0 del 192.9.203.21
The ip command syntax is:
$ ip a del 192.9.203.21 dev eth0
Enable or disable multicast
Enabling (or disabling)
multicast
on an interface with ifconfig happens with the
multicast argument:
# ifconfig eth0 multicast
With ip, use the set subcommand with
the device (dev) and a Boolean or toggle
multicast option:
# ip linkset dev eth0 multicast on
Enable or disable a network
Every sysadmin is familiar with the old "turn it off and then on
again" trick to fix a problem. In terms of networking interfaces,
that translates to bringing a network up or down.
The ifconfig command does this with the
up or down keywords:
# ifconfig eth0 up
Or you could use a dedicated command:
# ifup eth0
The ip command uses the set subcommand to
set the interface to an up or down state:
# ip linkset eth0 up
Enable or disable the Address Resolution Protocol (ARP)
With ifconfig, you enable ARP by declaring it:
# ifconfig eth0 arp
With ip, you set the arp property
as on or off:
# ip linkset dev eth0 arp on
Pros and cons of ip and ipconfig
The ip command is more versatile and technically more
efficient than ifconfig because it uses
Netlink sockets rather than ioctl system
calls.
The ip command may appear more verbose and more complex
than ifconfig, but that's one reason it's more
versatile. Once you start using it, you'll get a feel for its
internal logic (for instance, using set instead of a
seemingly arbitrary mix of declarations or settings).
Ultimately, ifconfig is outdated (for instance, it
lacks full support for network namespaces), and ip is
designed for the modern network. Try it out, learn it, use it.
You'll be glad you did!
Tuesday, April 6, 2021
Why use the Linux terminal
The command-line (aka terminal) is a scary thing for new Linux users. But
understanding it can be a huge step in your Linux journey and a significant
step in your career
If you're new to Linux, the command-line interface (also known as CLI
or terminal) may look scary. But it shouldn't. The CLI is a powerful and
resourceful tool that every aspiring Linux user should learn and be
comfortable with. On this article, let's review many reasons why you should
learn and use the command line, commonly (and often incorrectly) referred to
as terminal, shell, bash and CLI.
Ubiquitous
The command-line interface (CLI) is available in every operating system, not
only in Linux. Very frequently, developers and system administrators spend
most of the time in them. If you want to work with Linux and technology in
general, better start learning it.
Terminals are available in every operating system including Linux,
Windows and Macs
Powerful
CLI-based apps are much more powerful than their GUI-based equivalents. That
happens because usually GUIs are
wrappersaround libraries
developed by developers. Very frequently, these libraries contain way more
functionality than what's available in the graphical interface because, as you
might expect, since software development takes time and costs money to
produce, developers only add to GUI apps the most popular features.
For example, these are some of the options that the
GNU find tool provides
us:
Does your GUI-based find tool has all those options?
Quicker
Common and repetitive tasks are also faster in the terminal with the advantage
that you will be able to repeat and even schedule these tasks so they run
automatically, releasing you to do actual work, leaving the repetitive tasks
to computer.
For example, consider this standard development workflow:
If you were doing the above using a GUI-based git client (for example, Tortoise Git), the workflow would be similar to the below, taking you approximately 20
minutes to complete:
Right-click a folder in Nautilus (or Windows Explorer, or Finder) ->
Select clone -> Paster the Url -> Click OK
Wait for the download to Complete -> Click OK
Back to Nautilus -> Find File -> Open it
Make your changes (by probably using GEdit, KEdit or Visual Studio Code)
-> Save
Back to Nautilus
Right Click -> Commit
Right Click -> Push
Take a deep breath
In the terminal (for example, in Ubuntu),
the workflow would be equivalent to the below and could be completed in less
than 2 minutes:
sudo apt update && sudo apt install git -y # install
git
git clone <url> # clone the GitHub repo locally
vim/nano file -> save # edit the file using a text-based editor
git commit -m <msg> # commits the file locally
git push # push the changes back to our GitHub repo
Scriptable
Terminal/CLI-based tasks can be scripted (automated) and easily repeated
meaning that you will be able to optimize a big part of your workflow. Another
benefit is that these scripts
can be easily shared, exactly as
business and professional developers do!
So let's continue the above example. Our developer realized she is wasting too
much time in the GUI and would like to speed up her workflow even more. She
learned
some bash scripting
and wrote the function below:
gcp ()
{
msg="More updates";
if [ -n "$1" ]; then
msg=$1;
fi;
git add ./ && git commit -m "$msg" && git push
}
She's happy because now she can run from the terminal, the below command as
soon as she finishes her changes:
gcp <commit-msg>
What previously took 5 minutes is now is done in 2 seconds (1.8 seconds to
write the commit message and 0.2 to push the code upstream). A huge advantage
in her workflow. Imagine how much more productive she would be during the
course of her career!
It's important to always think how can you optimize your workflow. These small
optimizations add up to your productivity significantly over time.
Lightweight
Not only the CLI is faster and more lightweight than equivalent GUI-based
applications but it's quicker to run the same commands. For example, consider
a Git client like Tortoise Git. It was
supposed to be lightweight (what most GUI apps aren't) but it takes 3s to
completely load and uses 10Mb of memory:
Our GUI-based git client TortoiseGit
Meanwhile, its CLI equivalent, git status runs in 0.3s and consumes less than
1Mb. In other words, 20 times more efficient memory-wise and 10 times
faster.
A simple CLI command is 20x more efficient and 10x faster then its GUI
equivalent
Disk Space Efficient
Another advantage of terminal apps over their GUI-equivalents is reduced disk
space. For example, contrast these two popular apps. Can you spot the
differences?
Application
Installation Size
Total Size
Memory Usage
Visual Studio Code
80Mb
300Mb
500Mb (on sunny days)
Nano
0.2 Mb
0.8 Mb
3 Mb
400x more efficient
375x more efficient
160x more efficient
Extensible
Another important aspect is that the CLI is extensible. From it, skilled users
could easily either extend its basic functionality using its built-in features
like pipes and redirections combining inputs and outputs from different tools.
For example, sysadmins could list the first two users in the system who use
Bash as a shell, ordered alphabetically with:
What's interesting from the above command is how we combined 5 different tools
to get the results we need. Once you master the Linux terminal, you'll too
will be able to utilize these tools effectively to get work done significantly
faster!
This is a more advanced topic. We'll see in future posts more details about
it.
Customizable
As you might expect, the terminal is extremely customizable. Everything from
the prompt to functions (as seen above) and even custom keybindings can be
customized. For example, want to bind Ctrl+E to open the Nano text editor on the terminal? Simple. Add this to your
.bashrc
file:
bind '"\C-E":"nano\n"'
Extensive range of Apps
Contrary to what most newcomers thing, the terminal has apps too! You will
find apps for pretty much any use case. For example:
Want to work with Linux? Another important aspect of using the terminal is
that it will make you more ready for the job market. Since Linux servers
usually don't have GUIs, you will end up having to use some of the above tools
on your day-to-day work. So why not start now?
Learn more about Linux
Hopefully at this point you realize that you will learn way more about your
Linux system and computers in general when you use the terminal. This is the
secret sauce that the most productive developers want you to know!
It's also a huge win for testing new tools, maintaining your system,
installing software, fixing issues and tweaking as you wish.
Getting Started
Ready to get started on your terminal/CLI journey? Watch the video below:
Note: We don't have any affiliation with the video above. We just want you
to learn the terminal 😊
Conclusion
Every modern computer has a terminal. Learning it will save you time, allow
you to automate common actions, make you learn more about your system, save
time, grow professionally and be more comfortable with Linux. Well worth the
effort, isn't it?
If you recall our previous post, we started alluding to this
StackOverflow pool, where Linux was cited as the most loved technology by developers at 83%.
There are multiple reasons for that. Let's learn about them next.
Linux is free
Obviously, one of the main reasons to run Linux is because Linux is free. As poverty (unfortunately) grows around the world, it's
important to minimize costs for users and companies. Since prices for
Windows lincenses
are really high and utilizing
MacOS, almost
impeditive for most of us, being free allows Linux to reach a much wider
audience including independent developers, small organizations taught and used
in schools, universities and research labs at a really low cost.
Robust package management
While it's true that MacOS users can use
brew to enhance their terminal
experience, and even Microsoft is building Windows a package manager (despite
20years late 😌) they are nothing more than a poor adaptation of Linux's
built-in package mangers. It's on Linux where the real experience shines since
the package manager integrates into the update system which integrates into
the shell.
Quicker access to modern tools
You'll get quicker access to the latest releases of your favorite programming
language on Linux too. Linux users frequently get earlier access to
Golang,
Rust,
NodeJS - just to name some -
without resorting to building them from scratch.
Streamlined workflow
Beyond getting access to the latest tools, developing on Linux will be a much
more pleasant experience to to the nature of the system: an awesome and
powerful shell (Bash
on most cases) accessible via a powerful window manager (GNOME
or KDE) being backed by a super
solid system with an extensible list of packages available to install at your
fingertips.
Awesome command line tooling
Developers love the command line. Using the command line is key to automate
your tasks and to opmitze tasks, resulting in huge productivity gains. Today,
even tasks that are commonly UI-based such as browsing the web, managing files
and even watching
YouTube. Web developers
can gain signifiant productivity if they embrace this workflow which's the
recommended way to building new web apps quickly with
ReactJS, VueJS,
Angular. Popular tools
and frameworks such as WordPress and even proprietary tools such as
SendGrid or
HubSpot have their own
CLIs.
Plus, tools such as
tmux or
i3, allow you to multitask
without sacrificing your productivity.
On the left
man git, on the right: vim on top and htop on bottom
Streamlined cloud and container integration
As Red Hat usually says, containers are Linux. Creating your web app today requires probably a lot of dependencies, some
of which (a database server, for example) may not be trivial to install - or
may use a lot of your resources. Containers are today the way to streamline
that process as you can build complex applications with tools such
as Docker, Docker Compose and Minikube.
Dotfiles
Once you get comfortable with the shell, you'll probably want to customize
it to your needs. Developers realize that they really make them productive.
Since it's common days to work on multiple machines, an elegant solution to
that problem is to host your dotfiles in a private or public repository like GitHub so you can quickly restore your favorite settings in any of your
development machines.
Integrated Git
Git is an essential requirement today. On Linux git is an integral part of the
workflow (of course, it was invented by Linux Torvalds, Linux creator to
facilitate the complex integration workflow of the Linux kernel). Using git in
Linux makes everything simpler as it integrates into your command line and
shell.
A powerful shell
Bash (and siblings such as ZSH and Fish) is a really powerful tool in Linux.
Developers who know it can leverage it to enhance their workflows. For
example, you could map the following three commands:
git add .
git commit -m <your-message>
git push
As one operation, the following gcp command:
gcp(){ msg="More updates"
if [ -n "$1" ] then
msg=$1 fi
git add . && git commit -m "$msg" && git push; }
So that using it, would be:
gcp "Some commit message"
Oh, and simply typing gcp would do
all the above using "More updates" as the git commit message. Use but don't
abuse 😊.
Linux is reliable
Writing software requires a a reliable system. As you probably know, Windows
(and even Macs) are not as reliable as their companies
tell advertise. Your Linux system will rarely crash. You'll
also realize that Linux tools will be more stable than their Windows or Mac
equivalents.
Remember this?
Excellent Documentation
Developers have to frequently access the documentation. Linux comes the
man tool
allowing you access to the documentation you need available regardless of your
exposure to to the internet. Just run
man <cmd>
to view documentation for the software you need:
Good for old hardware
Linux is also excellent for old hardware. For example, you can run lighter tools
that utilize less resources. Most distributions (such as
Fedora LXDE
shown below) release alternative lightweight versions optimized for lower-end
hardware.
Updated Software
Another reason why developers love Linux is because (1) they're exposed to the
cutting edge software and (2) they'll get frequent updates/upgrades. Regarding
the latter, updates on Linux are not only reliable but are more frequent than
anything you'd get on those systems. The system will be updated multiple times a
week and a new version can be available every 6 months depending on the
distribution with long-term releases available every 2 years.
Outstanding software availability
Not only installing software on Linux is simple Every Linux distribution
provides a tool to manage software with lots (literally, thousands) of apps.
Visual Studio Code,
Slack? You'll find on Linux.
You'll also find enterprise software like
Zoom and
Microsoft Teams if
you need to talk to your clients.
Web development is all about networking. Linux comes with powerful networking
tools, some of which you probably heard of.
Samba,
nmap,
whois,
nslookup,
ping, curl,
ssh, among others are
natively available. There's just so much here and once you learn these tools
you probably wouldn't be able to work without them.
Cloud-native tools
Linux comes with lots of tools to use in cloud development. The most commons
are Docker (and its
sibbling podman) and
Kubernetes but it also
has easily installable access to tooling for
Azure,
AWS,
GCP and
devops/automation tooling such as
Ansible,
Helm,
Vagrant and more.
Support from a huge community
Linux users are spread around communities over the internet.
Being on Reddit
or on forums of your specific distribution, developers frequently share their
thoughts with similarly minded folks around the web. This helps them share
knowledge, news, learn new things and obviously, help others.
Linux is highly customizeable
Another reason web developers can benefit from using Linux is due to its
extensive customization. With the right instructions they can customize their
system as they wish resulting in a quicker setup or, in case containers aren't
sufficient, modelling their systems as per the customer's requirements.
Some of the things you can tweak in Linux are:
Desktop Managers: don't like
GNOME or
KDE? There's
XFCE,
LXQT,
LXDE, etc for you.
Login Managers: how you login to your system.
Desktop themes: configure themes, colors, etc.
Fonts: customize your fonts, sizes, etc.
Shell: shell is the application that runs on your terminal and also
can be changed or customized.
Systems and Services: your system will have an endless list of
services to choose from.
Kernel: even the kernel, the main process of your system can be
customized.
Enterprise-Grade Security
Linux comes with built-in enterprise security tooling. Beyond that, curated
repositories Linux users are used to having repositories curated by the
community and available for them. That means less viruses, no adware, unsafe
or untrusted software running on your machine.
Conclusion
On this post we understood a little more why developers use and love Linux. You
too could benefit from using it today! We hope you learned something new today
and are excited to try out Linux and use it as your main system as we do!
Following up on our previous discussion on
why use Linux, today we will discuss why Linux is the favorite operating system of
developers, the folks who build the software you use. To get started, let's
back up our assumption using
StackOverflow's own insights, where it shows Linux is the most loved technology by developers:
Linux is free
Obviously, one of the main reasons to run Linux is because Linux is free.
As poverty (unfortunately) grows around the world, it's important to minimize
costs for users and companies. Since prices for
Windows licenses are
really high and utilizing
MacOS, almost
impeditive for half of the world, being free allows Linux to reach a wider
audience including independent developers, small organizations, schools,
universities and research labs.
Linux is (way) more secure
Linux is also (way) more secure than Macs and Windows. That's mainly due to
its:
open-source code: due to its open nature, researches and hackers
frequently inspect and crack the code. When issues are found, they're
reported and fixed by community.
open collaboration model: open-source code also fosters open
collaborations. Developers from all over the world will frequently push
fixes to the software you use making it better and more secure.
enterprise-grade software: tools like
SELinux that are
run on mission critical environments run on your machine too.
different permission model: Linux users run on a low
permission level making it very improbable that even if you're hit by a
virus, you would infect the machine.
frequent updates: your system will always be updated getting the
latest security, software and kernel fixes. These are usually the holes
crackers explore to target you.
smaller exposure to viruses: yes, Linux has viruses but on an
infinite smaller proportion than Windows users get. Linux also has
anti-viruses if you need too.
curated repositories: the easiest way to install software on your
Linux is by using its own repositories. These repositories are curated and
are less prone to have viruses.
Awesome Command Line
Developers love the command line. Using the command line is key to automate your
tasks and to opmitze tasks, resulting in huge productivity gains. Today, even
tasks that are commonly UI-based such as browsing the web, managing files and
even watching YouTube can
be accomplished from the terminal. Plus, tools such as
tmux or
i3, allow you to multitask
without sacrificing your productivity.
On the left
man git, on the right: vim on top and htop on bottom
Linux is reliable
Writing software requires a a reliable system. As you probably know, Windows
(and even Macs) are not as reliable as their companies
tell advertise. Your Linux system will rarely crash. You'll
also realize that Linux tools will be more stable than their Windows or Mac
equivalents.
Add caption
Excellent Documentation
Developers have to frequently access the documentation. Linux comes the
man tool
allowing you access to the documentation you need available regardless of your
exposure to to the internet. Just run
man <cmd>
to view documentation for the software you need:
Good for old hardware
Linux is also excellent for old hardware. For example, you can run lighter tools
that utilize less resources. Most distributions (such as
Fedora LXDE
shown below) release alternative lightweight versions optimized for lower-end
hardware.
Updated Software
Another reason why developers love Linux is because (1) they're exposed to the
cutting edge software and (2) they'll get frequent updates/upgrades. Regarding
the latter, updates on Linux are not only reliable but are more frequent than
anything you'd get on those systems. The system will be updated multiple times
a week and a new version can be available every 6 months depending on the
distribution with long-term releases available every 2 years.
Streamlined cloud and container integration
As Red Hat usually says,
containers are Linux. Creating your application today requires probably a lot of dependencies,
some of which (a database server, for example) may not be trivial to install -
or may use a lot of your resources. Containers are today the way to streamline
that process as you can build complex applications with tools such as
Docker,
Docker Compose
and
Minikube.
Dotfiles
Once you get comfortable with the shell, you'll probably want to customize
it to your needs. Developers realize that they really make them productive.
Since it's common days to work on multiple machines, an elegant solution is
to hosting your dotfiles
in a private or public repository like
GitHub so you can quickly
restore your favorite settings in any of your development machines.
Integrated Git
Git is an essential requirement today. On Linux git is an integral part of the
workflow (of course, it was invented by Linux Torvalds, Linux creator to
facilitate the complex integration workflow of the Linux kernel). Using git in
Linux makes everything simpler as it integrates into your command line and
shell.
A powerful shell
Bash (and siblings such as ZSH and Fish) is a really powerful tool in Linux.
Developers who know it can leverage it to enhance their workflows. For
example, you could map the following three commands:
git add .
git commit -m <your-message>
git push
As one operation, the gcp command listed below:
gcp(){ msg="More updates"
if [ -n "$1" ] then
msg=$1 fi
git add . && git commit -m "$msg" && git push; }
So that using it, would be:
gcp "Some commit message"
Oh, and simply typing gcp would do
all the above using "More updates" as the git commit message. Use but don't
abuse 😊.
Outstanding software availability
Not only installing software on Linux is simple but Linux distributions come
with thousands of applications to choose from. Need communication software?
Linux has Slack,
Skype,
Zoom and even
Microsoft Teams. Need
a modern development environment? Try
Visual Studio Code.
Its really simple to install the build tools you'll need in Linux.
GCC,
Make,
glibc,
Gdb,
git and many other tools
needed on their development workflows are available either out of the box or
from their systems' package manager.
Powerful networking tooling
Linux is perfect for networking. And it offers lots, lots, and lots of tools
in the space. Some of them you probably heard of are
Samba,
nmap,
whois,
nslookup,
ping, curl,
ssh, among others.
There's just so much here and once you learn these tools you probably wouldn't
be able to work without them.
Cloud-native tools
Linux comes with lots of tools to use in cloud development. The most commons
are Docker (and its
sibling podman) and
Kubernetes but it also makes it very simple to install tooling for
Azure,
AWS,
GCP and
devops/automation tooling such as
Ansible,
Helm,
Vagrant and others.
Support from a huge community
Linux users are spread around communities over the internet.
Being on Reddit
or on forums of your specific distribution, developers frequently share their
thoughts with similarly minded folks around the web. This helps them share
knowledge, news, learn new things and obviously, help others.Curated
repositories Linux users are used to having repositories curated by the
community and available for them. That means no viruses, adware, unsafe or
untrusted software.
Linux is highly customizable
Another reason developers use Linux is due to its extensive customization.
Here are some of the things that can be customized on Linux:
Desktop Managers: don't like
GNOME or
KDE? There's
XFCE,
LXQT,
LXDE, etc for you.
Login Managers: how you login to your system.
Desktop themes: configure themes, colors, etc.
Fonts: customize your fonts, sizes, etc.
Shell: shell is the application that runs on your terminal and also
can be changed or customized.
Systems and Services: your system will have an endless list of
services to choose from.
Kernel: even the kernel, the main process of your system can be
customized.
Powerful hardware integrations
Into
IoT, Rasperry Pi,
Arduino? Due to the open
nature of these platforms and to the vast documentation available, developers
have access to an outstanding amount of technical information on how
everything works. And Linux is the best system to do so.
Conclusion
On this post we understood a little more why developers use and love Linux. You
too could benefit from using it today! We hope you learned something new today
and are excited to try out Linux and use it as your main system as we do!
