Tagged articles
init
42 articles · Page 1 of 1

ITPUBMay 18, 2026 · Industry Insights
The Unix V3 init(VII) manual famously declared “BUGS none possible,” a bold claim rooted in its tiny codebase, fixed hardware, tiny user base, and single‑author maintenance, a confidence that vanished by Unix V4 as complexity grew, illustrating the evolution from handcrafted init to modern systemd.
historyinitsoftware engineering
0 likes · 4 min read

An up‑to‑date guide based on systemd 256 examines the evolution from SysVinit, compares core features, startup mechanisms, dependency handling, process tracking, and security, and provides step‑by‑step migration, configuration examples, performance tuning, and troubleshooting tips for Linux administrators.
LinuxProcess Managementcgroups
0 likes · 27 min read

This article walks through the Linux kernel boot sequence on ARM platforms, covering self‑decompression, early initialization checks, page‑table setup, and the start_kernel routine that brings up hardware, memory management, scheduling, and the first user process.
ARMBootLinux
0 likes · 8 min read

This article breaks down the Linux boot sequence into ten clear stages—from power‑on self‑test and BIOS initialization to loading the kernel, executing init scripts, and finally presenting the login prompt—providing interview‑ready knowledge and detailed explanations for each step.
GRUBLinuxboot process
0 likes · 8 min read

This article explains how Python actually creates objects, clarifying the distinct roles of the __new__ and __init__ methods, and demonstrates practical techniques such as inheriting immutable types, adding metadata, and implementing singleton patterns through custom object creation.
Pythondesign-patternsimmutability
0 likes · 13 min read

This guide explains Linux's three main init systems, runlevels, and essential commands like service, chkconfig, and systemctl, showing how to view, enable, disable, and troubleshoot services while highlighting key configuration directories and unit types for effective system administration.
chkconfiginitservice management
0 likes · 12 min read

This guide explains the purpose and structure of a Linux root filesystem, demonstrates how to create a minimal rootfs using ext3 or NFS, walks through busybox compilation and configuration, analyzes init scripts and inittab, and shows how to package and flash the rootfs for embedded devices.
NFSbuildrootinit
0 likes · 32 min read

This guide walks through the complete Linux startup sequence, covering power‑on initialization, BIOS/UEFI boot, MBR/GRUB2 loading, kernel entry, init processes, ramdisk handling, run‑level configuration, fstab mounting, and user login mechanisms, illustrated with diagrams and key command references.
FilesystemGRUBLinux
0 likes · 12 min read

This article walks through the complete Linux boot sequence—including power‑on, BIOS/UEFI initialization, bootloader loading, kernel start, init processes, ramdisk, runlevels, filesystem mounting, and user login—illustrated with diagrams and key command details.
GRUBRunlevelUEFI
0 likes · 13 min read

This article walks through the Linux boot sequence on Debian, covering kernel loading, the init process, runlevel selection, startup script execution, user login methods, login shell initialization, and the role of non‑login shells, with command examples and diagrams.
DebianRunlevelSystem Startup
0 likes · 11 min read

Understanding Go's initialization sequence—package-level variable setup, init function calls, and main execution—helps developers avoid circular dependencies, ensure correct startup order, and optimize launch time, especially when integrating third‑party libraries that run their own init logic before your code.
GoInitializationPackage Variables
0 likes · 7 min read

This article explains the role of Python's __init__ constructor in object‑oriented programming, demonstrates how it initializes object attributes with example code, and shows how other methods can access those initialized values.
OOPPythonclass
0 likes · 5 min read

This guide explains how to create custom systemd service unit files, configure permissions, environment variables, logging, and resource limits, and shows how to start, stop, and monitor services using systemctl, with detailed examples and advanced options for Linux administrators.
LinuxServiceinit
0 likes · 8 min read

This article walks through the complete Linux startup sequence, covering power‑on initialization, BIOS/UEFI boot, MBR/GRUB2 loading, kernel and init processes, ramdisk usage, fstab mounting, and user login mechanisms, illustrated with diagrams and key code snippets.
GRUBLinuxUEFI
0 likes · 12 min read

This article walks through the three-stage Linux boot sequence—power‑on, BIOS/UEFI initialization, and kernel startup—detailing the role of MBR, GRUB2, init processes, runlevels, fstab configuration, and user login mechanisms.
GRUBLinuxboot process
0 likes · 11 min read

This guide explains the four main stages of a typical Linux boot sequence—BIOS POST, GRUB2 loading, kernel initialization, and systemd startup—detailing the hardware checks, bootloader behavior, init process, target units, and useful commands for inspecting and changing runlevels.
BIOSLinuxboot process
0 likes · 8 min read

This guide walks through the four essential stages of a Linux system’s startup—BIOS POST, the GRUB2 bootloader, kernel initialization, and systemd—explaining each step, the commands used to inspect targets, and how the process culminates in the user login prompt.
BIOSLinuxboot process
0 likes · 7 min read

This article explains why using Go's init() function is discouraged due to readability, testing complications, and error‑handling limitations, and it offers practical alternatives such as direct variable initialization, custom init functions with sync.Once, and controlled error‑aware initialization patterns.
BackendBest PracticesGo
0 likes · 8 min read

This article explains why Docker containers often stop right after starting, covering the role of PID 1, Linux init processes, daemonized services, and the container runtime architecture that determines container lifecycle.
initnginxpid1
0 likes · 8 min read

This article explains the differences between Python's __init__ and __call__ magic methods, demonstrates their behavior with example code, and shows how __call__ can be used to implement class decorators for callable objects.
__call__class decoratorinit
0 likes · 4 min read

This article explains the purpose and behavior of Python's __init__ constructor method, clarifies object-oriented concepts such as classes, instances, and attributes, and provides example code illustrating how __init__ is automatically invoked during object creation to initialize instance properties.
OOPPythonconstructor
0 likes · 4 min read

This article explains the complete Linux startup sequence, covering BIOS power‑on self‑test, interrupt vector initialization, MBR and partition table layout, multi‑stage bootloaders such as GRUB, kernel decompression, transition to protected mode, and the init system with runlevels.
BIOSGRUBLinux
0 likes · 25 min read

This guide explains how to use the Linux init command to change system runlevels, detailing each level’s purpose, the command syntax, and practical examples for shutting down, entering single‑user mode, switching to full multi‑user mode, launching the graphical interface, and rebooting the machine.
LinuxRunlevelinit
0 likes · 2 min read

This guide explains how the Linux runlevel command displays previous and current run levels, shows its syntax, provides practical examples, and expands on runlevel concepts, default levels, and their role in system boot and shutdown processes.
LinuxRunlevelUTMP
0 likes · 4 min read

This article introduces systemd as the modern Linux init replacement, explains its key features and unit file syntax, and provides three hands‑on examples showing how to manage nginx, Tomcat, and a custom JAR service with systemd commands and configuration files.
Linuxinitservice management
0 likes · 10 min read

The article explains Go's singleton pattern, detailing eager (init) and lazy implementations using sync.Mutex and sync.Once, provides full code examples, demonstrates that each accessor returns the same instance, and discusses trade‑offs between memory usage and performance.
ConcurrencyDesign PatternGo
0 likes · 5 min read

This article explains the Android Property system, detailing its shared‑memory architecture, the trie‑based data structures (prop_bt, prop_area, prop_info), the initialization flow in the init process, the core C APIs for adding, reading, updating and iterating properties, and the Java SystemProperties wrapper used by applications.
AndroidC++JNI
0 likes · 23 min read

This article explains how Objective‑C creates objects by detailing the two creation methods, the internal alloc and init implementations, the callAlloc workflow, memory allocation, and the final binding of the isa pointer, with full source code excerpts for each step.
Object CreationObjective-C++Runtime
0 likes · 11 min read

This article explains why Docker containers may need around ten seconds to stop, covering missing init processes, unhandled SIGTERM signals, and practical Dockerfile adjustments such as using exec‑form ENTRYPOINT, adding signal traps, or employing a lightweight init like tini.
DockerENTRYPOINTSIGTERM
0 likes · 9 min read

This article explains the fundamentals of Python class inheritance, covering five typical ways to use parent class attributes and methods—including direct calls, super() for private members, method overriding, invoking __init__, and passing initialization parameters—accompanied by clear code examples.
InheritancePythonclass
0 likes · 6 min read

This article explains the Linux boot sequence on Debian, covering BIOS handoff, kernel loading from /boot, the init process, runlevel configuration via /etc/rcN.d, startup script linking, three login methods, and how login and non‑login shells source configuration files such as /etc/profile and ~/.bashrc.
DebianRunlevelinit
0 likes · 11 min read


21CTOJun 29, 2019 · Fundamentals
This article walks through the Linux boot sequence on a Debian system, covering kernel loading, the init process, runlevel scripts, service management, and the various ways users log in, while also explaining the role of login and non‑login shells and Bash configuration files.
BootDebianRunlevel
0 likes · 11 min read


ITPUBJun 28, 2019 · Fundamentals
This article walks through the Linux boot sequence on Debian, covering kernel loading, the init process, runlevel selection, startup script linking, various login methods, and the handling of login and non‑login shells with concrete command examples.
DebianLinuxRunlevel
0 likes · 11 min read

This article explains the step‑by‑step boot sequence of a computer—from the BIOS reading the MBR on the selected storage device, through the boot loader loading the kernel, to the kernel initializing hardware, spawning the init process, and finally presenting the login screen.
BIOSLinuxboot process
0 likes · 6 min read

This article walks through every stage of a Linux system’s startup—from the hardware POST check and BIOS boot selection, through GRUB loading and kernel initialization, to the init process and run‑level scripts—providing clear explanations and essential commands for system administrators.
GRUBLinuxboot process
0 likes · 9 min read

This article demystifies the computer boot process, explaining how power‑on triggers BIOS, which loads the MBR, boot loader, kernel, init scripts, and finally presents the login screen, helping readers understand and troubleshoot each fragile stage.
BIOSLinuxMBR
0 likes · 6 min read

Discover how a Linux system powers up, covering the POST hardware check, BIOS boot selection, GRUB loading, kernel initialization, the init process with inittab configuration, and essential commands like chkconfig and init for managing runlevels and services.
GRUBLinuxboot process
0 likes · 8 min read

The article outlines the Linux boot sequence: BIOS performs hardware detection and self‑test, selects the boot device, runs the MBR boot loader (such as GRUB), loads the kernel which probes hardware and starts init, and finally init prepares the environment, starts services, and launches the login prompt.
BIOSGRUBLinux
0 likes · 2 min read


21CTOJun 11, 2016 · Mobile Development
This article explains the complete Android phone boot sequence—from power‑on, through the BIOS‑like bootloader, Linux kernel initialization, init and Zygote processes, to the launch of the first app and the desktop UI—in clear, step‑by‑step detail.
AndroidLinuxZygote
0 likes · 8 min read

This guide explains the complete boot sequence of CentOS 5, 6, and 7, covering GRUB stages, initrd, rc scripts, chkconfig, and the transition to systemd with its units, targets, and systemctl commands, providing practical commands and configuration examples.
CentOSGRUBLinux
0 likes · 15 min read

This guide explains Linux autostart services, the runlevel system, how to add or remove services via init scripts, rc.d directories, rc.local, and chkconfig, and details the purpose of each of the seven runlevels for effective system management.
LinuxServicesautostart
0 likes · 5 min read

This article explains the differences between code, programs, and processes in Linux, demonstrates how to compile and run a simple program, explores parent‑child relationships, the role of the init process, the process lifecycle, and the copy‑on‑write mechanism.
Linuxcopy-on-writeexec
0 likes · 10 min read
