Course Length:

5 Days

Course Description:

This intensive course rapidly trains programmers to develop applications and programs on Red Hat Enterprise Linux. Over the span of five days, you'll get hands-on training, concepts, and demonstrations with emphasis on realistic labs and programming exercises. Learn concepts and skills essential to programming and software development for Linux-based applications and products.

Who Should Attend:

The course is for experienced C programmers who want to learn key skills for creating applications and programs on Red Hat Enterprise Linux. This course is also useful for Windows and UNIX programmers migrating their programs to Linux.

Benefits of Attendance:

Upon completion of this course, students will be able to:

• Develop applications and programs on Red Hat Enterprise Linux.

Prerequisites:

Students should have experience in C programming, RH133 or equivalent UNIX or Linux workstation user skills for developers, shell scripting in a UNIX or Linux environment, and experience with editors such as vi, emacs.

Course Outline:

• GCC - GNU Compiler Collection
  1. GNU Compiler Collection
  2. History of GCC
  3. Four Stages of GCC
  4. Interrupting the Compiler
  5. Compiling a C Program
  6. Preprocessor Features
  7. Predefined Preprocessor Symbols
  8. Warnings and Extensions
  9. Optimization
  10. Linking
• Building Software with Make
  1. Introducing make(1)
  2. How make Works
  3. Makefile Rule Syntax
  4. Example: Makefile First Steps
  5. Makefile Improved
  6. Implicit Rules
  7. Example: Simpler Is Better Makefile
  8. Variables
  9. Defining Variables
  10. Example: Makefile with Variables
  11. Automatic Variables
  12. Special Targets
  13. Defining Useful Phony Targets
• The GNU C Library and System Calls
  1. Library Goals
  2. Library Standards
  3. GNU C Library - glibc
  4. Library Functions vs. System Calls
  5. Using System Calls
  6. Handling Errors with errno
  7. Making Sense of errno
  8. Using strace
• Program Arguments and Environment
  1. Program Startup
  2. Using argc/argv
  3. Handling Options with getopt()
  4. Handling Options with getopt_long()
  5. Environment
  6. Manipulating the Environment
  7. Program Exit
  8. Registering Exit Handlers
• Building Libraries
  1. Why Use Libraries?
  2. Static Versus Shared
  3. Static Library Benefits
  4. Shared Library Benefits
  5. Creating a Static Library
  6. Using Static Libraries
  7. Creating a Shared Library
  8. Using Shared Libraries
  9. Shared Library Management
  10. Library Locations
  11. ldconfig
• Time Functions
  1. When Does Time Begin?
  2. Time Data Types
  3. Determining Real Time
  4. Converting time_t
  5. Converting tm Structure
  6. Process Time
  7. Time arithmetic
  8. Second Resolution Timers
  9. Fine-Grained Timers
  10. < Real Time Clock (RTC)
• Process Management
  1. What a Process Is
  2. Process Relationships
  3. Create a Child Process
  4. Doing Something Else
  5. Related execve() Functions
  6. Wait For a Child
  7. More Precise Waiting
  8. Changing Priority/Nice
  9. Real Time Priority
• Memory Operations
  1. Allocating/Freeing Memory
  2. Memory Alignment
  3. Locked Memory
  4. Memory Copy/Initialization
  5. Memory Comparison/Search
• Debugging
  1. What Is My Program Doing?
  2. Source Level Debugging
  3. Invoking gdb
  4. Getting Started with gdb
  5. Examining and Changing Memory
  6. Debuginfo Libraries
  7. Using gdb with a Running Process
  8. Using gdb to Autopsy a Crash
  9. Debugging Libraries - ElectricFence
  10. Debugging with valgrind
  11. Profiling for Performance
• Basic File Operations
  1. Stream vs. System Calls
  2. Opening/Closing Streams
  3. Stream Input/Output Functions
  4. Stream Status/Errors
  5. Stream File Positioning
  6. Stream Buffering
  7. Temporary/Scratch Files
  8. Opening/Closing File Descriptors
  9. File Descriptor I/O
  10. Repositioning File Descriptors
  11. Stream/File Descriptor Conversions
  12. cat using ANSI I/O
  13. cat using POSIX I/O
• Communicating with Pipes
  1. Introduction to Pipes
  2. Standard I/O: popen()/pclose()
  3. Using popen()/pclose()
  4. System Call: pipe()
  5. Using pipe()
  6. Named Pipes
  7. Using Named Pipes
  8. For Further Reading
• Managing Signals
  1. What Signals Are
  2. Blocking/Checking Signals
  3. Working with Signal Sets
  4. Example of Blocking Signals
  5. Handling Signals with sigaction()
  6. sigaction() Example
  7. Handling Signals with signal()
  8. Sending Signals
  9. Real-Time Signals
• Programming with Threads
  1. Introducing Threaded Programming
  2. Applications Suited to Threads
  3. Building Threaded Programs
  4. Creating Threads
  5. Thread Identity
  6. Synchronizing by Joining
  7. Detaching Threads
  8. Stopping Threads
  9. Synchronizing with Mutexes
  10. Using Mutexes
  11. Read/Write Locks
  12. Conditional Variables
  13. Using Conditional Variables
  14. A Conditional Variable Gotcha
  15. For Further Reading
• Advanced File Operations
  1. Directory Operations
  2. File System Operations
  3. Multiplexed I/O with select()
  4. Miscellaneous I/O Functions
  5. Memory Mapped I/O
  6. Using Memory Mapped I/O
  7. File Locking
• Interprocess Communication (IPC)
  1. Interprocess Communication (IPC)
  2. POSIX IPC Overview
  3. POSIX Shared Memory
  4. POSIX Semaphores
  5. POSIX Message Queues
  6. System V IPC Overview
  7. System V IPC Shared Memory
  8. System V IPC Semaphore Arrays
  9. System V IPC Message Queues
• Basic Network Programming
  1. Linux Networking Overview
  2. Getting Started with socket()
  3. Client Functions
  4. Specifying IPv4 Addresses
  5. Host Versus Network Byte Order
  6. Example TCP/IP Client
  7. Address Conversion Functions
  8. Using getaddrinfo()
  9. Server Functions
  10. Example TCP/IP Server
  11. Datagram Communication with UDP
• Working with the Linux Community
  1. Getting in Touch with the Community
  2. General Considerations
  3. Building a Community
  4. Licenses
  5. GPL
  6. LGPL
  7. BSD
  8. Creative Commons