>
~$linuxier
Read the blog
~$ home /Development

Development

Linux is where most software gets built, and the terminal is the developer's real IDE. This track is about the tools that live between "I have an idea" and "it runs in production" — git for tracking every change, build tools and toolchains for turning source into binaries, careful control of package versions so your code doesn't rot, and isolated environments like Python virtualenvs that keep one project from stepping on another. Everything here is designed to make your setup reproducible: the same commands, the same versions, the same result on your laptop and on the server.

start here

The groundwork every developer track needs.

Dedicated git and build-tool guides are on the way. In the meantime, these two cover the shell fluency and package know-how the rest of this track builds on.

command-line.sh
$ git status && make && ./run
# the developer's inner loop is all shell
Foundations

How to Use the Command Line on Linux

Navigating a repo, running a build, tailing logs — every development workflow rides on the terminal. Get the file, path and permission basics down cold.

read the guide →
toolchain.sh
$ apt search --names-only build-essential
Build tools

Finding Compilers & Libraries with apt

Before you can build anything you need a toolchain. Learn to search the archive for gcc, make, headers and -dev packages — and install the exact versions you want.

read the guide →
venv.sh
$ python3 -m venv .venv && source .venv/bin/activate
Environments

Isolated Environments & venvs

Keep each project's dependencies in its own sandbox. The command-line skills here are the foundation for virtualenvs, containers and reproducible builds.

read the guide →
More guides landing soon. Dedicated walkthroughs for git branching, Makefiles, version pinning and Python virtual environments are in the pipeline. New tutorials land here regularly — check back, or start with the two foundations above.
what you'll learn

From source to
something that ships.

01
Version control with gitTrack every change, branch without fear, and recover from mistakes — git init, commit, branch and merge as daily habits.
02
Build tools & toolchainsInstall build-essential, understand make and configure, and turn a folder of source into a working binary.
03
Package versionsPin dependencies so your project is reproducible: know what version you have, and how to hold or upgrade it deliberately.
04
Virtual environmentsGive each project its own isolated dependencies with Python venv (and beyond) so nothing bleeds between builds.
why it matters

Reproducible beats "works on my machine".

Two ideas run through everything in this track — and both come down to controlling exactly what code and which versions run.

Track every change with git

Version control isn't just backup — it's a time machine and a collaboration layer. Branches let you try an idea without risk, commits document why something changed, and git log answers "when did this break?" long after you've forgotten. It's the single highest-leverage tool a developer can learn.

Isolate your environments

Global installs collide. One project needs an old library, another needs the newest — and system Python belongs to the OS, not to you. Virtual environments (and containers) give each project its own sealed box of dependencies, so upgrades stay local and a fresh clone builds the same everywhere.

AltStyle によって変換されたページ (->オリジナル) /