DEV Community: Uilian Ries

Getting prepared for LPI certifications with LPI Lab

Uilian Ries — Sat, 28 Mar 2026 19:58:38 +0000

I'm glad to introduce the LPI Lab, the ultimate app designed to help you master your Linux Professional Institute (LPI) exams. Whether you're aiming for Linux Essentials, LPIC-1, or LPIC-2 certifications, LPI Lab is your daily go-to tool for comprehensive and effective preparation.

The idea for LPI Lab came from a real need during my own certification journey. While studying for LPIC-1, I relied on official documentation, man pages, and books. Those resources are essential, but I felt there was still something missing: a fast and convenient way to practice every day, especially during small breaks in a busy routine.

That’s exactly why LPI Lab was built: to make certification prep more practical and help learners feel ready to pass on their first attempt.

Features at a Glance

Here’s a quick overview of what LPI Lab offers to support your certification journey:

Practice Mode: Customize your study sessions with specific question counts and time limits.
Simulation Mode: Experience the real exam environment with timed, realistic conditions.
Interactive Questions: Tackle multiple question types with instant feedback and detailed explanations.
Comprehensive Support: Full coverage for Linux Essentials (010-160), LPIC-1 (101-500, 102-500), and LPIC-2 (201-450, 202-450).
Offline Access: All practice questions are available offline, ensuring you never have to stop learning.

Roadmap for 2026

Thinking about the next steps and evolution of the app, a roadmap has been prepared to introduce new features, including:

LPIC-3: Full support for all 4 most advanced exams from LPI
Security Essential: Second new exam covering the Essentials certifications
New Language Support: Add Spanish and Portuguese, including for all questions
Performance Tracking: Interactive graphs showing your score improvement over time.

To obtain more details, check the Complete Roadmap

Get Started Today

Ready to take your Linux skills to the next level? Download LPI Lab from the Google Play Store and start your journey towards becoming a certified Linux professional.

Download LPI Lab on Google Play

For more information, visit the official website: LPI Lab

Let's achieve our certification goals together!

Faker C++: Generate Realistic Fake Data for Testing and Development

Uilian Ries — Thu, 04 Jul 2024 12:51:28 +0000

Hey there, C++ developers! 👋 Are you tired of creating mock data for your tests and prototypes? Say hello to Faker C++, a powerful library designed to generate realistic fake data for C++ applications. Let's dive into what makes this library special and how it can supercharge your development workflow.

What is Faker C++?

Faker C++ is a C++ library inspired by the popular Faker.js, aimed at providing developers with a robust tool for generating fake (but realistic) data. Whether you're building test suites, populating databases, or creating demos, Faker C++ has got you covered. It's open source and under MIT license.

Key Features

📚 Realistic Data Generation: Generate various types of data including names, addresses, emails, dates, and more.
🛠 Modular Design: Choose from a wide range of modules like Internet, Location, String, Date, and more to generate specific types of data.
🚀 Easy Integration: Seamlessly integrate with CMake, and it supports major compilers like MSVC, GCC, Clang, and Apple Clang.

Quick Example

Here's a taste of what you can do with Faker C++:

// main.cpp
#include <cstdlib>
#include <iostream>

#include "faker-cxx/Internet.h"
#include "faker-cxx/Location.h"
#include "faker-cxx/String.h"

int main()
{
    const auto id = faker::String::uuid();
    const auto email = faker::Internet::email();
    const auto password = faker::Internet::password();
    const auto city = faker::Location::city();
    const auto streetAddress = faker::Location::streetAddress();

    std::cout << id << std::endl;
    std::cout << email << std::endl;
    std::cout << password << std::endl;
    std::cout << city << std::endl;
    std::cout << streetAddress << std::endl;

    return EXIT_SUCCESS;
}

Consuming and using Faker C++

Let's see how to install and link to faker library.

Installing with Conan 2.x

Faker C++ can be easily installed and integrated into your projects using Conan. Here's how you can do it:

First, make sure you have Conan 2.x installed. If not, you can install it using pip:

pip install conan

To install faker-cxx, run the following command:

conan install -r conancenter --requires="faker-cxx/[*]" --build=missing

This command will fetch the latest version of faker-cxx and build it if necessary.

If you want to use faker-cxx in your CMake project, you can create a conanfile.txt in your project root with the following content:

[requires]
faker-cxx/[*]

[generators]
CMakeDeps
CMakeToolchain

[layout]
cmake_layout

Using this conanfile.txt, Conan will provide faker-cxx CMake files under the folder build/Release/generators/

Consuming Faker C++

Once you've set up Faker C++ and compiled your code, you can run your example to generate and display fake data.

First, let's configure the CMakeLists.txt, in order to link:

cmake_minimum_required(VERSION 3.15)
project(example)

find_package(faker-cxx REQUIRED)
add_executable(example main.cpp)
target_link_libraries(example faker-cxx::faker-cxx)
target_compile_features(example cxx_std_20)

Now, we configure and build our example using Faker:

cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=build/Release/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
cmake --build build

Now we can run our example using fake data:

build/example

11e9c8cc-04f8-49b2-ae28-afd6c5724e6d
CurtisShields@gmail.com
w(*Ba.u3!N@;Pz8
Shawnee
341 Meredith Hill

This output showcases a UUID, email address, password, city, and street address, all generated randomly by Faker C++. You can use similar functions to generate various other types of fake data as per your project’s requirements.

Supported Modules

Faker C++ comes with a plethora of modules, each designed to generate specific types of data:

🖥️ Internet: emails, usernames, passwords, IP addresses.
🏢 Location: countries, cities, zip codes, street addresses.
🎨 String: UUIDs, alphanumeric, numeric, hexadecimal strings.
📖 Date: past and future dates.
🐼 Animal: bears, birds, cats, dogs.

And many more including modules for Commerce, Company, Finance, Food, Music, Sport, Vehicle, etc.

Community and Contributions

Faker C++ is an open-source project and welcomes contributions! Whether you're fixing bugs, adding new features, or improving documentation, your help is appreciated. Check out our Contributing Guide for more details. Join our Discord server to connect with other contributors.

Conclusion

Faker C++ aims to be the go-to library for generating fake data in C++ projects. It's designed to make your testing and development process smoother and more efficient. Give it a try in your next project and let us know what you think!
Check out the full documentation to explore all the capabilities of Faker C++. Happy coding! 🚀

Building a Linux distro for OrangePi with Buildroot

Uilian Ries — Sat, 03 Apr 2021 17:49:07 +0000

"If you wish to make an apple pie from scratch, you must first invent the universe." (Carl Sagan)

Or, If you want to blink a led, you must first build your system.

Introduction

Building an embedded system, be it Linux or another kernel, from scratch, can be a difficult and time-consuming task in many cases. For such situations there are tools that automate the process of generating toolchains, dependencies and patches. Among them is Buildroot, developed by the same maintainers of uClibc.

On this post we will build an entire Linux distro for Orange Pi Zero, using Buildroot to save our time. To check if all worked, we will also access board's UART by its serial interface and connect to Wi-Fi.

Orange Pi Zero

The Orange PI Zero is another cheap single-board, similar to Raspberry Zero W.

It's equipped with Allwinner H2 SoC, which provides a Quad-core Cortex-A7 processor.

The Linux Embedded System

Before proceeding, let's look at the basic architecture of an embedded system based on Linux:

It can be divided in few layers:

💻 The hardware is the physical part, where your device will be used to run the operating system and its applications.

👢 The bootloader is responsible for basic hardware initialization, through a configuration word, in addition to passing parameters, loading and executing the Linux Kernel.

🐧 The Kernel is the core of the system, performs device management, task scheduling and abstracts communication with the user. In this case we will use Linux as the target Kernel.

🐚 RootFS is where the user space is located, all applications (e.g shell, init, ..) and libraries (e.g. libc, zlib, openssl..) are stored there.

🔧 Toolchain is a set of tools to generate the system binaries, like the compiler, kernel header files, libc version and C headers.

Although many embedded platforms already offer Linux images ready to be used, such as Raspberry Pi, these images usually have a large number of packages already installed, making the product stuffed.

Buildroot is a tool designed for Linux, with the objective of generating an embedded Linux system through cross-compilation, all in a simplified and fast way. It is capable of generating all the components presented above, in a very friendly way, using a set of Makefiles that can be managed through a graphical interface.

How to install Buildroot

Buildroot is not an application, but a repository, so that, we can use its download page or Github repository for cloning.



wget https://buildroot.org/downloads/buildroot-2021.02.tar.gz
tar zxf buildroot-2021.02.tar.gz
cd buildroot-2021.02/

How to build the Linux image

First step is configuring Buildroot to use the default configuration for Orange Pi.

NOTE: You may not use root privileges for building operations.

make orangepi_zero_defconfig

Based on Orange Pi Zero default configuration, Buildroot will generate the file .config, used to build our entire system.

In addition to Orange Pi, Buildroot also supports other platforms. Pre-supported configurations are listed in the configs/ directory, but it is possible to list all of them using the command:

make list-defconfigs

As you can see, Buildroot supports a large range of platforms, including Freescale, Banana Pi, Raspberry Pi and others.

Before building our image, let's take a look on Buildroot menu using its ncurses interface.

make menuconfig

Now you should have the follow interface:

This menu helps us to customize our platform, currently it shows our .config definitions. We can change toolchain, Kernel version, libc flavor, applications, libraries for rootfs, init system, bootloader project, and more.

We will keep it as it is. If you change anything by mistake, just exit without saving, or run defconfig command again to regenerate a default configuration file.

Now let's build our system.

NOTE: This part takes around 2 hours and requires 7 GB on your disk and internet connection.

Buildroot will download all projects from sources, cross-build them to Orange Pi architecture and compile to a minimal image. To build the image, run:

make

After some ☕ and if everything went correctly, you will have the follow file:



ls -lh output/images/sdcard.img 
-rw-r--r-- 1 uilian uilian 71M mar 27 17:54 sdcard.img

Besides other files, here we are only interested on sdcard.img. That small file, contains all we need to run our platform, bootloader, kernel and rootfs.

How to prepare the SD Card

We will need a micro SD card to store our image. Its capacity should be bigger than our image. After connecting the SD card to your computer, we will need to discover where it is mounted:

sudo fdisk -l
Disk /dev/mmcblk0: 942 MiB, 987758592 bytes, 1929216 sectors

It is mounted under /dev/mmcblk0, but may vary according your Linux distro.

To write our Linux system image in the SD card we will run dd command:

sudo dd if=output/images/sdcard.img of=/dev/mmcblk0 bs=4M status=progress conv=fdatasync

Done, we need to insert the micro SD card in our Orange Pi and turn on. The first boot takes more time, led D7 should light up after few seconds.

If your board doesn't start, make sure your power supply provides 5VDC 2A and your card is well inserted.

Serial connection

Now is time to use the UART interface for communication. For that, we will need a USB/UART converter. It's a very cheap board with many variations available.

For this step, it's important use the correct connection order.

The Rx (receptor) from converter must be connected to Tx (transmitter) on the Orange Pi board.
The Tx (receptor) from converter must be connected to Rx (transmitter) on the Orange Pi board.
The GND (Ground), must be connected to GND from both sides.

To detect where your converter is connected, after connecting it to your USB, let's take a look on USB devices.

lsusb
Bus 002 Device 012: ID 0403:6001 Future Technology Devices International, Ltd FT232 Serial (UART) IC

dmesg | grep FTDI
[49255.816532] ftdi_sio 2-1:1.0: FTDI USB Serial Device converter detected
[49255.816940] usb 2-1: FTDI USB Serial Device converter now attached to ttyUSB0

Now we know that the UART converter is linked to /dev/ttyUSB0. It may vary according your Linux distro.

For this tutorial, I'll use picocom, but you can use what you prefer.

sudo picocom -b 115200 -f n /dev/ttyUSB0

Orange Pi Login

After accessing the Orange Pi by its serial connection and turning it on, we will observe its initialization from the beginning.

The boot process is long, here we will list only few parts to give an idea about its output.



U-Boot SPL 2020.10 (Mar 27 2021 - 17:53:25 -0300)
DRAM: 256 MiB
Trying to boot from MMC1

U-Boot 2020.10 (Mar 27 2021 - 17:53:25 -0300) Allwinner Technology

CPU:   Allwinner H3 (SUN8I 1680)
Model: Xunlong Orange Pi Zero
DRAM:  256 MiB
MMC:   mmc@1c0f000: 0, mmc@1c10000: 1
...
Starting kernel ...

[    0.000000] Booting Linux on physical CPU 0x0
...
Welcome to Buildroot for the Orange Pi Zero
OrangePi_Zero login:

The bootloader U-Boot recognizes the board, showing its hardware properties. After that, it starts the Linux kernel, passing a configuration word. Once loaded, Linux looks for the program init, which should start all user space services, session and so on.

The default username for login is root. No password is required, but if you want to add one, you may use passwd command.

Wi-Fi Connection

The Orange Pi Zero offer Wireless hardware support and the basic Buildroot configuration already integrates it. Let's configure our board to work with our Wi-Fi.

We will use wpa_supplicant program. First, we need to update its configuration file. On the Orange Pi terminal, let's execute:

vi /etc/wpa_supplicant.conf

Replace the default network session by:



network={
    ssid="MY HOME NETWORK NAME"
    psk="MY HOME PASSWORD"
    id_str="home"
}

Where you should replace SSID and PSK according your wireless network. Once configured, you have to start the client.

wpa_supplicant -B -Dnl80211 -iwlan0 -c/etc/wpa_supplicant.conf

Now you should be authenticated and connected to your Wi-Fi, but no IP address is obtained yet. To request a new address by DHCP, we will use udhcpc command.



udhcpc -i wlan0
udhcpc: started, v1.33.0
udhcpc: sending discover
udhcpc: sending select for 192.168.0.18
udhcpc: lease of 192.168.0.18 obtained, lease time 3600
deleting routers
adding dns 1.1.1.1
adding dns 8.8.8.8

And we check just running a simple ping test.



ping -I wlan0 8.8.8.8

PING 8.8.8.8 (8.8.8.8): 56 data bytes

64 bytes from 8.8.8.8: seq=0 ttl=113 time=34.668 ms

64 bytes from 8.8.8.8: seq=1 ttl=113 time=26.845 ms

Conclusion

Building a Linux system from scratch can be quite a challenge without having the right tools to assist. As we have seen, Buildroot is an important means when it comes to integrating all layers that form a complete image.

As next challenge, you can customize your image through menuconfig, adding packages and generating a new image.

Happy hacking.