Training > Web & Application > Developing Applications For Linux (LFD401)
INSTRUCTOR-LED COURSE

Developing Applications For Linux (LFD401)

Learn how to develop applications for the Linux environment. In this instructor-led course, you’ll get hands-on experience with the necessary tools and methods for Linux application development and learn about the features and techniques that are unique to Linux.

Who Is It For

This course is for experienced developers. Students should be proficient in C programming, and be familiar with basic Linux utilities and text editors.
read less read more
What You’ll Learn

In this course you will learn about the tools and methods for developing C programs and doing systems programming under Linux, debugging techniques, process management, Linux specific paid and system calls, and more.
read less read more
What It Prepares You For

This course will prepare you to develop applications for a Linux environment.
read less read more
Course Outline
Expand All
Collapse All
Introduction
- Objectives
- Who You Are
- The Linux Foundation
- Copyright and No Confidential Information
- Linux Foundation Training
- Certification Programs and Digital Badging
- Linux Distributions
- Platforms
- Preparing Your System
- Using and Downloading a Virtual Machine
- Things Change in Linux and Open Source Projects
Preliminaries
- Procedures
- Standards and the LSB
How to Work in OSS Projects **
- Overview on How to Contribute Properly
- Know Where the Code is Coming From: DCO and CLA
- Stay Close to Mainline for Security and Quality
- Study and Understand the Project DNA
- Figure Out What Itch You Want to Scratch
- Identify Maintainers and Their Work Flows and Methods
- Get Early Input and Work in the Open
- Contribute Incremental Bits, Not Large Code Dumps
- Leave Your Ego at the Door: Don’t Be Thin-Skinned
- Be Patient, Develop Long Term Relationships, Be Helpful
Compilers
- GCC
- Other Compilers
- Major gcc Options
- Preprocessor
- Integrated Development Environments (IDE)
- Labs
Libraries
- Static Libraries
- Shared Libraries
- Linking To Libraries
- Dynamic Linking Loader
- Labs
Make
- Using make and Makefiles
- Building large projects
- More complicated rules
- Built-in rules
- Labs
Source Control
- Source Control
- RCS and CVS
- Subversion
- git
- Labs
Debugging and Core Dumps
- gdb
- What are Core Dump Files?
- Producing Core Dumps
- Examining Core Dumps
- Labs
Debugging Tools
- Getting the Time
- Profiling and Performance
- valgrind
- Address Sanitizer
- Labs
System Calls
- System Calls vs. Library Functions
- How System Calls are Made
- Return Values and Error Numbers
- Labs
Memory Management and Allocation
- Memory Management
- Dynamical Allocation
- Tuning malloc()
- Locking Pages
- Labs
Files and Filesystems in Linux **
- Files, Directories and Devices
- The Virtual File System
- The ext2/ext3 Filesystem
- Journaling Filesystems
- The ext4/ Filesystem
- Labs
File I/O
- UNIX File I/O
- Opening and Closing
- Reading, Writing and Seeking
- Positional and Vector I/O
- Standard I/O Library
- Large File Support (LFS)
- Labs
Advanced File Operations
- Stat Functions
- Directory Functions
- inotify
- Memory Mapping
- flock() and fcntl()
- Making Temporary Files
- Other System Calls
- Labs
Processes - I
- What is a Process?
- Process Limits
- Process Groups
- The proc Filesystem
- Inter-Process Communication Methods
- Labs
Processes - II
- Using system() to Create a Process
- Using fork() to Create a Process
- Using exec() to Create a Process
- Using clone()
- Exiting
- Constructors and Destructors
- Waiting
- Daemon Processes
- Labs
Pipes and Fifos
- Pipes and Inter-Process Communication
- popen() and pclose()
- pipe()
- Named Pipes (FIFOs)
- splice(), vmsplice() and tee()
- Labs
Asynchronous I/O**
- What is Asynchronous I/O?
- The POSIX Asynchronous I/O API
- Linux Implementation
- Labs
Signals - I
- What are Signals?
- Signals Available
- Dispatching Signals
- Alarms, Pausing and Sleeping
- Setting up a Signal Handler
- Signal Sets
- sigaction()
- Labs
Signals - II
- Reentrancy and Signal Handlers
- Jumping and Non-Local Returns
- siginfo and sigqueue()
- Real Time Signals
- Labs
POSIX Threads - I
- Multi-threading under Linux
- Basic Program Structure
- Creating and Destroying Threads
- Signals and Threads
- Forking vs. Threading
- Labs
POSIX Threads - II
- Deadlocks and Race Conditions
- Mutex Operations
- Semaphores
- Futexes
- Conditional Operations
- Labs
Networking and Sockets
- Networking Layers
- What are Sockets?
- Stream Sockets
- Datagram Sockets
- Raw Sockets
- Byte Ordering
- Labs
Sockets - Addresses and Hosts
- Socket Address Structures
- Converting IP Addresses
- Host Information
- Labs
Sockets - Ports and Protocols
- Service Port Information
- Protocol Information
- Labs
Sockets - Clients
- Basic Client Sequence
- socket()
- connect()
- close() and shutdown()
- UNIX Client
- Internet Client
- Labs
Sockets - Servers
- Basic Server Sequence
- bind()
- listen()
- accept()
- UNIX Server
- Internet Server
- Labs
Sockets - Input/Output Operations
- write(), read()
- send(), recv()
- sendto(), recvfrom()
- sendmsg(), recvmsg()
- sendfile()
- socketpair()
- Labs
Sockets - Options
- Getting and Setting Socket Options
- fcntl()
- ioctl()
- getsockopt() and setsockopt()
- Labs
Netlink Sockets**
- What are netlink Sockets?
- Opening a netlink Socket
- netlink Messages
- Labs
Sockets - Multiplexing and Concurrent Servers
- Multiplexed and Asynchronous Socket I/O
- select()
- poll()
- pselect() and ppoll()
- epoll
- Signal Driven and Asynchronous I/O
- Concurrent Servers
- Labs
Inter Process Communication
- Methods of IPC
- POSIX IPC
- System V IPC**
- Labs
Shared Memory
- What is Shared Memory?
- POSIX Shared Memory
- System V Shared Memory**
- Labs
Semaphores
- What is a Semaphore?
- POSIX Semaphores
- System V Semaphores**
- Labs
Message Queues
- What are Message Queues?
- POSIX Message Queues
- System V Message Queues**
- Labs
Closing and Evaluation Survey
- Evaluation Survey

** These sections may be considered in part or in whole as optional. They contain either background reference material, specialized topics, or advanced subjects. The instructor may choose to cover or not cover them depending on classroom experience and time constraints.
Prerequisites
This course is for experienced developers. Students should be proficient in C programming, and be familiar with basic Linux utilities and text editors.
Reviews
Sep 2022
John B. was very knowledgeable, and I appreciated his ability to answer most questions with real world applications. His knowledge of the Linux kernel also helped explain how/why certain things work the way they do.
Sep 2022
Instructor was fantastic!
Sep 2022
Instructor was great!
Sep 2022
John was very friendly, and was able to answer questions about the course in a way that was easy to digest and understand.
Sep 2022
The exposure to the Linux API was well organized. The labs really helped solidify some of the more intimidating topics, such as threads and concurrency in Linux.
Sep 2022
The range of material covered was great.
Sep 2022
Having a big chunk of time dedicated to labs was really great. It's not something I have experienced with other LF classes I have taken, and I think it helped solidify some topics, and allowed me to experiment with different APIs and interfaces outside of what was expected from the lab prompt. John was nice and punctual, and I liked how he allowed students to show the live debug problems they were having.
Sep 2022
I do like how we had a consistent schedule of topics, then labs. It allowed us to learn a concept, then experiment with said concept.
Sep 2022
The student material, the lab exercises, and being able to clarify doubts was great. The lab exercises were fantastic! The instructor was patient and knowledgeable, and took the time to explain things visually, when the material required it. He paced the course well, and was on time throughout. He respected the time for labs, and gave a lot of time for lab exercises.
Sep 2022
I liked that we were given enough time to do the labs during the course. The labs definitely helped solidify what was being taught. I've taken other Linux courses before, but was never really given enough time for the labs. I understand that this may be difficult in other courses with heavier content, but that's what I liked about this course.