DEV Community: LabEx

Display User and Group Information Challenge Solution

Labby — Thu, 09 Jul 2026 00:56:34 +0000

The LabEx challenge Display User and Group Information is short, but it tests an important Linux reflex: before reasoning about permissions, confirm which user the shell is running as and which groups that user belongs to.

Unlike a guided lab, this is a challenge. The page gives the required outcome, but it expects you to choose the commands yourself. The solution comes from matching each requirement to the Linux command that reports exactly that information.

Problem Summary

The challenge has two tasks:

Display the current user identity.
Display detailed user and group information, including uid, gid, and groups.

That means the answer needs two levels of identity information. The first task only wants the username. The second task wants the numeric and named identity fields Linux uses for access decisions.

Step 1: Print the Current Username

For the first task, use whoami.

whoami

The expected output is only the current username. In the LabEx environment, it may look like this:

labex

This command answers a narrow question: "Which user am I right now?" It does not show groups, IDs, or permission details. That is why it is the right command for the first requirement, but not enough for the second one.

Step 2: Print User and Group Details

For the second task, use id.

id

The output should include the user ID, primary group ID, and supplementary groups:

uid=1000(labex) gid=1000(labex) groups=1000(labex),4(adm),24(cdrom),27(sudo)

The exact numbers and group names can differ between environments. What matters is the structure:

uid=1000(labex) means the current user has numeric user ID 1000 and username labex.
gid=1000(labex) means the primary group ID is 1000 and the group name is labex.
groups=... lists every group membership available to the current user.

Why These Commands Solve the Challenge

whoami solves the first requirement because it prints only the current username. If the challenge asks for a single user identity, this is the cleanest output.

id solves the second requirement because it includes the fields named in the prompt: uid, gid, and groups. You do not need to inspect /etc/passwd or /etc/group for this challenge. Those files can explain account configuration, but the task asks for the identity information of the current session, and id reports that directly.

The common mistake is to stop after whoami. That confirms the username, but it does not prove group membership. In Linux permission checks, group membership can be the difference between access granted and access denied.

Final Answer

Run these two commands:

whoami
id

You have completed the challenge when the first command prints the current username and the second command prints identity details containing uid, gid, and groups.

Learn Linux Through Operational Challenges

Labby — Wed, 08 Jul 2026 04:15:53 +0000

Many Linux beginners can remember a command before they know where it belongs. They can run touch, chmod, ss, or systemctl, but still hesitate when a task has a working directory, an existing file, a service that must stay running, and a specific result to verify.

That gap is where command practice starts to become operational practice.

The contrast is simple: a command list teaches syntax, while an operational challenge forces the command to answer a real constraint.

100 Days of Linux is built around that gap. The course is not a list of 100 unrelated commands. It is a sequence of 100 small Linux challenges, each framed as a task with context, scope, a required final state, and acceptance criteria.

The first challenge is intentionally small. In "Claim the Drop Folder", the learner starts in /home/labex/project, finds an existing drop-folder/incoming directory, and creates a ready.flag file in that exact location. The command may be as simple as touch, but the real lesson is not the command name. The learner has to confirm the working directory, avoid creating the marker in the wrong place, and leave the existing folder structure intact.

That pattern repeats across the course: a command is useful only when it changes the right thing and leaves the rest of the system alone.

The syllabus makes the progression visible. The first ten days focus on handoffs: claiming a folder, inventorying a delivery, reading a welcome note, preparing a review folder, and closing the first handoff. The next sections move through reading operational evidence, safe file changes, access boundaries, running work reliably, local app validation, tooling, managed services, recovery, and final operations simulations.

That structure gives the command a job. A checklist can tell a learner that chmod 600 file restricts a file to its owner. A challenge can make that command matter by placing it inside a specific handoff: a private manager note already has the correct content, but its mode is too open. The task is to change the permission while preserving the file and its contents.

The same approach works for networking and services. In one local app validation challenge, the learner must identify which candidate TCP port is actually listening by inspecting local sockets with a command such as ss -ltn, then copy only the matching port card into a review folder. The service must remain running. The final state matters as much as the inspection command.

Later tasks add more moving parts without turning into vague troubleshooting exercises. A maintenance challenge asks the learner to schedule a prepared heartbeat script with cron and confirm that the expected output file appears. A recovery challenge asks them to inspect mounts under /mnt, locate a staged recovery card, copy it into the project intake folder, and leave the mount available.

By the final day, the task has become a compact incident. The learner must close a broken local status API by reading service evidence, fixing config access for the labex service user, clearing stale process state, starting labex-status-api.service, and verifying that http://127.0.0.1:18200/health returns the expected status lines. That is still beginner-scoped, but it is no longer isolated command recall.

Across these examples, the same small loop keeps coming back.

The useful habit running through the course is constraint-aware work:

Know the current workspace before changing files.
Read the existing structure instead of recreating it.
Preserve content when the task is only about permissions or placement.
Inspect evidence before acting on a service or port.
Verify the final state with the same precision as the task description.

Those habits are hard to build from reference material alone. They come from repeated small tasks where a wrong directory, an extra copy, a deleted file, or an unverified service changes the outcome.

For someone who has already learned basic commands but still feels slow in a Linux terminal, the first useful step is not another command list. Start with the early handoff challenges in 100 Days of Linux, then move into the permissions, service, and recovery sections once the basic file tasks feel routine.

Linux Journey Is Now Part of LabEx

Labby — Mon, 08 Jun 2026 01:38:17 +0000

Linux Journey has been one of the most popular free resources for learning Linux since 2015.

Created by Cindy Quach, the project has helped millions of beginners take their first steps into Linux through simple lessons and quizzes.

Today, Linux Journey is officially part of LabEx.

The original Linux Journey website (https://linuxjourney.com) now redirects to https://labex.io/linuxjourney.

Our goal is straightforward: keep Linux Journey free, open source, and actively maintained for the next generation of Linux learners.

We'll continue maintaining existing lessons, fixing issues, improving translations, and adding new beginner-friendly content over time.

The official repository is now maintained by the LabEx team:

https://github.com/labex-labs/linuxjourney

We've also recently launched the Linux Journey iOS app, making it easier to learn Linux on the go:

https://apps.apple.com/app/linux-journey/id6770861660

Most importantly, nothing changes about what made Linux Journey special.

It remains free. It remains open source. It remains community-driven.

A huge thank you to Cindy Quach and all contributors who helped build Linux Journey into one of the most loved Linux learning resources on the internet.

We're honored to continue the journey.

Master Git: How to Undo Commits, Switch Branches, and Manage Tags Effectively

Labby — Sun, 07 Jun 2026 17:27:55 +0000

Every developer has been there: a messy commit history, confusion over branch switching, or the need to mark a release milestone. Git is the backbone of modern software development, but mastering it requires more than just memorizing commands. This learning path takes you through three practical scenarios that turn Git from a daunting tool into your most reliable project assistant.

How to Undo and Remove a Specific Git Commit from Current Branch

Difficulty: Beginner | Time: 15 minutes

Learn how to undo and remove a specific Git commit from the current branch. Discover the best practices for managing Git commit history and restoring removed commits.

DEV Community: LabEx

Display User and Group Information Challenge Solution

Problem Summary

Step 1: Print the Current Username

Step 2: Print User and Group Details

Why These Commands Solve the Challenge

Final Answer

Learn Linux Through Operational Challenges

Linux Journey Is Now Part of LabEx

Master Git: How to Undo Commits, Switch Branches, and Manage Tags Effectively

How to Undo and Remove a Specific Git Commit from Current Branch

Git Switch vs Git Checkout

Tagging Your Project's History

4 Wireshark Labs: Master Network Analysis, Nmap Scanning, and Metasploit Exploitation

Use Nmap and Metasploit for Network Scanning and Vulnerability Analysis

Exploit Unreal IRCd Vulnerability with Nmap and Metasploit

Network Analysis with Wireshark

Explore and Customize Wireshark Interface

Master Java Core: 5 Hands-On Labs for OOP, Threading, and Encryption

Arranging Classes by Functionality

Overloading and Overriding

Implement Countdown Timer Thread

Class and Object

Implement Encryption and Decryption

Master Linux Command Line: Custom Variables, User Auditing, and File Redirection

Creating Custom Variables

Users and Groups Explained

Redirection to Files

Master Docker: Command Quest, Image Organization, and Container Execution Labs

Docker Arena Command Quest

Superpower Image Organization in Docker

Docker Execute Command in Container

CKS Training: Master Debugging, API Migration, and Volume Management Labs

Use exec and Port Forwarding for Debugging

Update Deprecated API Manifests

Use Ephemeral and Persistent Volumes in Pods

Master LFCS Training: 3 Hands-on Labs for Process and Job Management

Set Up Scheduled Tasks

Linux Process Management

Background Job Management

5 CSS Flexbox Projects: From Responsive Dice to Flexible Card Layouts

Responsive Dice Layout with Flexbox

Simple and Beautiful Home Page Design

Give Your Page a Makeover

Fruit Arrangement with CSS Flexbox

Responsive Flexible Card Layout

Master MySQL Views and Window Functions: Advanced Query Optimization Guide

MySQL Views and Virtual Tables

MySQL Window Functions