This chapter covers macOS and Linux basics as tested in CompTIA A+ Core 2 (220-1102) Objective 1.6. You will learn the fundamental differences between these two Unix-like operating systems, their filesystem structures, common command-line tools, and troubleshooting techniques. Approximately 10-15% of the Operating Systems domain questions touch on macOS or Linux, making this a moderate but critical topic. Mastery here ensures you can support both platforms in a mixed environment.
Jump to a section
Think of an operating system as a professional kitchen. Windows is a fast-food chain: everything is standardized, you press a button and get a predictable result, but customization is limited. macOS is a high-end restaurant kitchen: it looks beautiful, the tools are intuitive, and the workflow is smooth, but you can't change the layout of the stoves. Linux is a modular kitchen in a food truck: you start with an empty shell, pick your own stove, fridge, and countertop (desktop environment), and you can rearrange everything. The 'chef' (user) in both macOS and Linux can access the command line (Terminal) to issue precise instructions. In macOS, the Terminal uses a Unix foundation (Darwin) similar to Linux, so many commands work identically. However, macOS has a graphical 'Finder' that hides the filesystem complexity, while Linux often expects you to know the command line. Both systems use case-sensitive filesystems (by default on Linux, optional on macOS), and both treat everything as a file—including hardware devices. The CompTIA A+ exam expects you to navigate both kitchens: know the common commands, understand the filesystem hierarchy, and be able to perform basic troubleshooting without relying on a GUI.
macOS and Linux share a common Unix heritage. macOS is built on Darwin, an open-source Unix-like operating system derived from NeXTSTEP. Linux is a Unix-like kernel created by Linus Torvalds, combined with GNU utilities. Both are POSIX-compliant, meaning they support a standard set of commands and system calls. The CompTIA A+ 220-1102 exam expects you to know basic navigation, file management, and troubleshooting commands for both.
Filesystem Hierarchy
Both systems use a hierarchical filesystem starting at the root directory /. Key directories include:
/bin – Essential user command binaries (e.g., ls, cp)
/sbin – System binaries for administration (e.g., fdisk, ifconfig)
/etc – Configuration files
/var – Variable data like logs (/var/log)
/tmp – Temporary files
/home – User home directories (Linux)
/Users – User home directories (macOS)
/Applications – Installed applications (macOS)
/Volumes – Mounted drives (macOS)
macOS also has /System and /Library for system frameworks. The exam may ask about these paths.
Command Line Basics
Both macOS and Linux use a terminal emulator. The default shell on macOS is Zsh (since Catalina), while Linux often uses Bash. Common commands:
ls – List directory contents. Options: -l (long format), -a (all files including hidden), -h (human-readable sizes).
cd – Change directory.
pwd – Print working directory.
cp – Copy files. Syntax: cp source destination. Use -r for directories.
mv – Move or rename.
rm – Remove files. Use -r for directories, -f to force. Be careful: no recycle bin.
mkdir – Create directory.
rmdir – Remove empty directory.
cat – Concatenate and display file content.
less – View file content page by page.
grep – Search text using patterns. Example: grep 'error' /var/log/system.log
chmod – Change file permissions. Permissions: read (4), write (2), execute (1). Example: chmod 755 script.sh
chown – Change file owner. Example: chown user:group file
ps – List processes. ps aux shows all processes.
kill – Terminate process by PID. kill -9 PID forces kill.
top – Display real-time processes (Linux). htop is enhanced but not default.
dmesg – Print kernel ring buffer messages (useful for hardware issues).
ifconfig – Configure network interfaces (older). ip addr on modern Linux.
ping – Test network connectivity.
traceroute – Trace route to host (Linux). macOS uses traceroute as well.
nslookup – Query DNS (deprecated, but still tested). dig is modern.
sudo – Execute command as superuser. Example: sudo apt update
macOS-Specific Commands
defaults write – Modify user defaults (plist files). Example: defaults write com.apple.finder AppleShowAllFiles YES
diskutil – Manage disks. Example: diskutil list
dscacheutil – Directory service cache utility. dscacheutil -flushcache flushes DNS cache.
system_profiler – Display system hardware/software information.
pmset – Power management settings. pmset -g shows current settings.
spctl – Security policy (Gatekeeper). spctl --master-disable disables Gatekeeper.
csrutil – System Integrity Protection (SIP) status. csrutil status
Linux-Specific Commands
apt-get or apt – Package management on Debian/Ubuntu. apt update && apt upgrade
yum – Package management on RHEL/CentOS (older). dnf is modern.
systemctl – Control systemd services. systemctl start service, systemctl enable service
journalctl – View systemd logs. journalctl -u service
ip – Modern network configuration. ip addr, ip route
nmtui – Network Manager text user interface.
fdisk – Partition table manipulator.
mount – Mount filesystems. mount /dev/sdb1 /mnt
umount – Unmount filesystem.
File Permissions
Both systems use the same permission model: three types (read, write, execute) for three categories (owner, group, others). View with ls -l. Example output:
-rwxr-xr-- 1 user group 1024 Mar 15 10:00 file.shFirst character: file type (- file, d directory). Next nine characters: permissions. rwx = owner has all; r-x = group read/execute; r-- = others read only. Numeric: chmod 754 file means owner=7 (rwx), group=5 (r-x), others=4 (r--).
Boot Process
macOS: Boot ROM -> EFI -> boot.efi -> kernel (XNU) -> launchd (PID 1) -> user space. Linux: BIOS/UEFI -> bootloader (GRUB) -> kernel -> init/systemd -> user space.
Troubleshooting
Common issues:
- Application won't launch: Check permissions, verify file integrity, check console logs (macOS: Console app, Linux: journalctl or /var/log/syslog).
- Network connectivity: Use ping, ifconfig/ip addr, check DNS with nslookup. On macOS, networksetup -listallnetworkservices shows interfaces.
- Slow performance: Use top/htop to find CPU/memory hogs, df -h for disk space, du -sh * for directory sizes.
- Cannot install software: Check package manager (Linux) or Gatekeeper (macOS). For Linux, ensure repositories are updated (apt update). For macOS, allow apps from unidentified developers via System Preferences > Security & Privacy.
Recovery Modes
macOS Recovery: Boot with Command+R (Intel) or hold power button (Apple Silicon). Options: Disk Utility, Reinstall macOS, Terminal, Restore from Time Machine.
Linux Recovery: Boot into single-user mode (add single or init=/bin/bash to kernel command line) or use a live USB.
Key Differences from Windows
No drive letters; everything under /.
Case-sensitive filenames (Linux default, macOS optional).
Forward slashes in paths.
Hidden files start with dot (.).
Command line is powerful and often required for troubleshooting.
Package managers instead of .exe/.msi.
Exam Tips
The 220-1102 exam focuses on:
Recognizing common commands and their outputs.
Understanding the filesystem structure.
Knowing how to change permissions and ownership.
Basic troubleshooting steps (e.g., check disk space, kill process, flush DNS).
Differences between macOS and Linux where they diverge (e.g., package managers, recovery modes).
Memorize key commands and their options. Practice in a virtual machine or dual-boot environment.
Boot the System
For macOS, press the power button. On Intel Macs, you can boot into Recovery Mode by holding Command+R immediately after the chime. On Apple Silicon, hold the power button until you see startup options. For Linux, the BIOS/UEFI loads the bootloader (GRUB), which presents a menu. If no input, it boots the default kernel. The kernel initializes hardware, mounts the root filesystem, and starts the init process (systemd on modern distros). The boot process can be observed via `dmesg` or `journalctl -b`.
Open Terminal
On macOS, go to Applications > Utilities > Terminal, or use Spotlight (Command+Space, type 'Terminal'). On Linux, use the desktop environment's terminal emulator (e.g., GNOME Terminal, Konsole) or switch to a virtual console with Ctrl+Alt+F1-F6. The terminal provides a shell prompt (e.g., `username@hostname:~$`). The default shell on macOS is Zsh; on Linux, it's often Bash. Both support tab completion, command history (up arrow), and piping (`|`).
Navigate the Filesystem
Use `pwd` to see current directory. Use `cd` to change directories: `cd /etc` goes to /etc, `cd ~` goes home, `cd ..` goes up one level. Use `ls` to list contents: `ls -la` shows all files with details. Hidden files (starting with dot) are shown with `-a`. Use `find` to search: `find / -name '*.conf'` finds all .conf files starting from root. Use `locate` (if installed) for faster searches via a database.
Manage Files and Permissions
Create a directory with `mkdir newdir`. Copy a file with `cp source dest`. Move/rename with `mv old new`. Delete with `rm file` (use `-r` for directories). Change permissions with `chmod 755 file` (owner rwx, group rx, others rx). Change owner with `chown user:group file`. To view permissions, `ls -l`. The `umask` command sets default permissions for new files. For example, `umask 022` results in 755 for directories, 644 for files.
Install and Update Software
On macOS, most software is installed via the App Store or drag-and-drop .app bundles. Command-line tools can be installed via Homebrew (`brew install package`). On Linux, use the package manager: `sudo apt update && sudo apt install package` (Debian/Ubuntu), `sudo yum install package` (RHEL/CentOS), or `sudo dnf install package` (Fedora). Always update package lists before installing. To remove, `sudo apt remove package`. To upgrade all, `sudo apt upgrade`.
Troubleshoot Network Issues
First, check connectivity with `ping 8.8.8.8` (if fails, check physical connection). Use `ifconfig` (macOS/Linux) or `ip addr` (Linux) to see IP address. Check DNS with `nslookup google.com` or `dig google.com`. On macOS, flush DNS cache with `sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder`. On Linux, restart networking with `sudo systemctl restart networking` or `sudo service network-manager restart`. Use `traceroute` to identify where packets are dropped.
In a typical enterprise environment, macOS and Linux systems serve different roles. macOS is often used by designers, developers, and executives who prefer the user experience and integration with other Apple devices. Linux dominates server infrastructure, cloud instances, and embedded systems. A systems administrator might manage a mixed environment where they support both platforms.
Scenario 1: Web Server Migration
A company is migrating a web server from a Windows IIS to a Linux Apache server. The administrator must transfer files, set permissions, and configure the web server. Using scp or rsync to copy files, chmod to set correct permissions (e.g., 755 for directories, 644 for files), and chown to set ownership to www-data. They also need to configure Apache virtual hosts in /etc/apache2/sites-available/. Common pitfalls: forgetting to enable the site with a2ensite, or incorrect SELinux contexts (on RHEL-based systems) causing 403 errors.
Scenario 2: macOS Support for Developers
A software development team uses macOS laptops. The IT support team must handle issues like application crashes, network connectivity, and software installation. For example, a developer cannot install a tool via Homebrew because of permission issues. The administrator runs sudo chown -R $(whoami) /usr/local/bin to fix ownership. Another common issue is DNS cache corruption causing 'server not found' errors; flushing the DNS cache resolves it. The support team also uses system_profiler SPHardwareDataType to gather hardware info for warranty claims.
Scenario 3: Linux Server Hardening
A security team needs to harden a Linux server. They disable root login via SSH (PermitRootLogin no in /etc/ssh/sshd_config), change default SSH port, and configure firewall with iptables or ufw. They use chmod to secure configuration files (e.g., /etc/shadow should be 640 or 600). They also set up fail2ban to block brute-force attacks. Regular updates are applied via unattended-upgrades. Misconfiguration of permissions can lead to service failures or security breaches, so careful testing is required.
The CompTIA A+ 220-1102 exam tests Objective 1.6: 'Given a scenario, use appropriate macOS and Linux tools and commands.' The exam expects you to know:
Common commands: ls, cd, pwd, cp, mv, rm, mkdir, rmdir, cat, less, grep, chmod, chown, ps, kill, top, dmesg, ifconfig, ping, traceroute, nslookup, sudo. You must know their basic options. For example, ls -la shows all files with details; chmod 755 sets rwx for owner, rx for group/others.
Filesystem hierarchy: Know that /etc holds config files, /var/log holds logs, /home (Linux) and /Users (macOS) hold user homes, /Applications is for apps on macOS, /Volumes for mounted drives.
macOS specific: Recovery mode (Command+R on Intel, hold power on Apple Silicon), Terminal, Disk Utility, System Preferences, Gatekeeper, SIP (csrutil status).
Linux specific: Package managers (apt, yum, dnf), systemd (systemctl), GRUB bootloader, virtual consoles (Ctrl+Alt+F1-F6).
Common wrong answers:
Confusing chmod and chown: chmod changes permissions, chown changes ownership. A common trap is asking to 'change permissions' and offering chown as an answer.
Mixing up kill options: kill -9 is SIGKILL (force kill), kill -15 is SIGTERM (graceful). The exam may ask which command forces a process to stop.
Thinking ifconfig is the only network command: on modern Linux, ip is preferred, but ifconfig is still valid and tested.
Assuming macOS and Linux are identical: they share many commands but have different default shells (Zsh vs Bash), different recovery methods, and different filesystem layouts (e.g., /Users vs /home).
Edge cases:
The exam may ask about a command that exists on both but with different behavior. For example, traceroute on Linux uses ICMP by default, while on macOS it uses UDP. However, the exam typically tests the command name, not the protocol.
File permissions: be able to interpret -rwxr--r-- (owner rwx, group r, others r). Numeric: 744.
Hidden files: start with .; ls -a shows them.
Superuser: sudo is used; su switches user. Know that sudo requires the user to be in the sudoers file.
How to eliminate wrong answers:
If the question asks for 'list files', the answer must include ls. Options like dir (Windows) or list are wrong.
If the question involves 'change directory', the answer is cd.
If the question involves 'view process list', the answer is ps or top. ps aux shows all processes.
If the question involves 'search text in files', the answer is grep.
If the question involves 'network configuration', look for ifconfig or ip.
If the question involves 'package installation', look for apt (Debian) or yum (RHEL). The exam may specify the distribution.
Memorize these commands and practice in a lab environment. The exam expects practical knowledge, not just theory.
macOS and Linux are both Unix-like; many commands are identical (ls, cd, cp, mv, rm, chmod, chown, ps, kill, grep, sudo).
The filesystem root is `/`; macOS uses `/Users` for home directories, Linux uses `/home`.
File permissions: read=4, write=2, execute=1; chmod 755 gives owner rwx, group rx, others rx.
Hidden files start with a dot (.) and are shown with `ls -a`.
macOS Recovery: Command+R (Intel) or hold power button (Apple Silicon).
Linux package managers: apt (Debian/Ubuntu), yum/dnf (RHEL/Fedora).
Common troubleshooting: check disk space with `df -h`, process list with `ps aux` or `top`, network with `ping` and `ifconfig`.
Use `sudo` to run commands as superuser; `su` switches user.
Flush DNS on macOS: `sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder`.
The exam expects you to know command options like `ls -la`, `chmod 755`, `ps aux`, `kill -9`.
These come up on the exam all the time. Here's how to tell them apart.
macOS
Default shell is Zsh (since macOS Catalina).
Package management via App Store, Homebrew (third-party), or .app bundles.
Filesystem: uses HFS+ or APFS; case-insensitive by default.
Recovery mode: Command+R (Intel) or hold power button (Apple Silicon).
GUI is integral; command line is secondary for most users.
Linux
Default shell is Bash (many distros), but Zsh is also common.
Package management via apt, yum, dnf, pacman, etc., depending on distribution.
Filesystem: ext4, XFS, Btrfs, etc.; case-sensitive by default.
Recovery: single-user mode, live USB, or GRUB rescue.
GUI is optional; many servers run headless.
Mistake
macOS and Linux are completely different operating systems with no common commands.
Correct
Both are Unix-like and share many commands such as `ls`, `cd`, `cp`, `mv`, `rm`, `chmod`, `chown`, `ps`, `kill`, `grep`, `ping`, `ifconfig`, and `sudo`. The differences lie in package managers, default shells, filesystem paths (e.g., `/Users` vs `/home`), and recovery methods.
Mistake
The `chmod` command changes file ownership.
Correct
`chmod` changes file permissions (read, write, execute). `chown` changes file ownership (user and group). For example, `chmod 755 file` sets permissions; `chown user:group file` changes owner.
Mistake
You cannot delete files from the command line without a recycle bin.
Correct
The `rm` command permanently deletes files. There is no recycle bin in the terminal. Use with caution; consider `rm -i` for interactive confirmation or `trash-cli` on Linux for a safer alternative.
Mistake
Linux does not have a graphical user interface.
Correct
Linux can run desktop environments like GNOME, KDE, Xfce, etc. Many servers run headless (no GUI), but desktop distributions like Ubuntu, Fedora, and Linux Mint provide full GUIs. The exam focuses on command-line tools but acknowledges GUI exists.
Mistake
macOS Recovery Mode is only accessible via Command+R on all Macs.
Correct
On Intel Macs, Command+R boots into Recovery. On Apple Silicon Macs, you must hold the power button until startup options appear, then click Options. Apple Silicon also has a built-in recovery partition accessible via the power button.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
`chmod` changes file permissions (read, write, execute) for owner, group, and others. `chown` changes the ownership of a file (user and/or group). For example, `chmod 755 file.sh` sets permissions; `chown user:group file.sh` changes owner to 'user' and group to 'group'. On the exam, if the question says 'change permissions', the answer is `chmod`; if 'change owner', it's `chown`.
Use `ls -a` or `ls -la` for a detailed listing. The `-a` flag shows all files, including those starting with a dot (hidden files). `-l` gives a long format with permissions, size, and date. Example: `ls -la /home/user`.
`kill -9 PID` sends SIGKILL, which immediately terminates the process without cleanup. For a graceful termination, use `kill -15 PID` (SIGTERM). On the exam, 'force kill' implies `-9`. Example: `kill -9 1234`. You can find the PID with `ps aux` or `pgrep`.
Use `apt-get` or `apt`. First, update the package list: `sudo apt update`. Then install: `sudo apt install package-name`. To remove: `sudo apt remove package-name`. To upgrade all: `sudo apt upgrade`. On RHEL/CentOS, use `yum install package-name` or `dnf install package-name`.
Recovery Mode provides utilities like Disk Utility, Terminal, and Reinstall macOS. On Intel Macs, restart and hold Command+R until the Apple logo appears. On Apple Silicon Macs, hold the power button until startup options appear, then click Options. It's used for troubleshooting, disk repair, and OS reinstallation.
Use `df -h` to see disk usage in human-readable format (e.g., GB, MB). To see directory sizes, use `du -sh directory-name`. Example: `df -h` shows mounted filesystems and their used/available space. `du -sh /home` shows the size of the /home directory.
`sudo` allows a permitted user to execute a command as the superuser (or another user) based on the /etc/sudoers file. `su` switches the current user to another user (default root) and requires the target user's password. `sudo` is more secure because it logs commands and limits privileges. Example: `sudo apt update` runs apt as root; `su -` switches to root shell.
You've just covered macOS and Linux Basics for A+ — now see how well it sticks with free 220-1102 practice questions. Full explanations included, no account needed.
Done with this chapter?