UNT | University of North Texas

Search form

CSCE 3600: Principles of Systems Programming

Course Number: 
CSCE 3600
Course Name: 
Principles of Systems Programming
Description: 

Introduction to the design and operation of systems software. Analysis is made of current system software technology, including operating systems, language translation systems and file systems.

Start Date: 
Monday, May 3, 2004
Last Review Date: 
Thursday, April 2, 2015
Prerequisite (should have grade of C or better): 
Credit Hours (Including Labs): 
3.00
UNT Topics: 
  1. Introduction
    1. UNIX and UNIX-like operating systems
    2. What operating systems do
    3. Kernel
    4. System call
    5. Layered OS architecture
    6. Applications that come with OS
    7. Format for commands in a shell
    8. Examples of shell commands
    9. File and directory permissions
    10. Text editors
    11. Everything is a file
    12. Redirection
    13. Pipes
    14. Filters
    15. C and C++
    16. I/O in C
    17. Strings in C
    18. Makefiles
    19. Debugger
  2. Parsing
    1. Command line argument
    2. argc and argv in C
    3. Separating arguments with spaces
    4. Converting from strings to numeric types in C
  3. Regular Expressions
    1. Regular expression
    2. Examples of programs that use them
    3. Globbing
    4. Metacharacter
    5. Grep
    6. Character ranges
    7. Character classes
    8. Quoting and escaping
    9. Sed
    10. Awk
    11. Find
  4. Bash
    1. Shell
    2. Bourne again shell
    3. Why use shells
    4. What shells do
    5. Standard I/O
    6. EOF signal
    7. Shell metacharacters
    8. Shell substitutions
    9. Shebang
    10. Shell scripting
    11. Debugging shell scripts
  5. Processes 
    1. Definition of process
    2. Process vs program
    3. Sequential execution
    4. Parts of a process
    5. Process control block
    6. Process scheduler
    7. Scheduling queue
    8. Scheduler types
    9. Process types
    10. Context switch
    11. Process creation
    12. Process tree
    13. Resource sharing
    14. Address space
    15. Execution options
    16. Process termination
    17. Signals
    18. Scheduling algorithm metrics
    19. Scheduling algorithms
  6. Concurrency
    1. Threads
    2. Parts of a thread
    3. Resource sharing with threads
    4. Switching between threads
    5. Relationship between threads and processes
    6. POSIX threads
    7. Thread safety
    8. Synchronizing threads
    9. Concurrent processes
    10. Process creation
    11. Relationship between parent and child processes
    12. Things that child processes inherit from their parent processes
    13. Race conditions
    14. Signals
  7. Streams, Pipes, and Files
    1. Everything is a file
    2. Sources of input
    3. Sources of output
    4. Unidirectional movement of data
    5. Sequential access
    6. UNIX files
    7. UNIX file types
    8. File processing
    9. File operations
    10. Streams
    11. Standard I/O
    12. Buffered and unbuffered I/O
    13. File descriptor
    14. File access mode
    15. File offset
    16. File status
    17. System calls
    18. Files as pipes for data
    19. I/O redirection
    20. Interprocess communication
  8. Sockets
    1. As extension of pipe
    2. Categories
    3. Client-server model
    4. Socket system calls
    5. Socket operations
    6. IP protocol layers
    7. As network API
    8. Byte order
    9. Hostname
    10. IP address
    11. Port number
    12. I/O multiplexing
    13. TCP vs UDP
  9. Compilation
    1. Compiler
    2. Interpreter
    3. Assembler
    4. Linker 
    5. Loader
    6. Preprocessor
    7. Finding performance bottlenecks
    8. Profilers
  10. Compiler Construction
    1. Reasons for building compilers
    2. Reasons for studying compilers
    3. Properties of a compiler
    4. Syntax and semantics
    5. Compilation process
    6. Regular expressions
    7. Context-free grammars
    8. Error handling in compilers
  11. Mutual Exclusion
    1. Independent processes
    2. Cooperating processes
    3. Producer-consumer problem
    4. Race condition
    5. Critical section problem
    6. Dekker’s and Peterson’s algorithms
    7. Interrupts
    8. Semaphores
  12. Virtual Memory
    1. How a program starts running
    2. Virtual memory
    3. Virtual memory advantages
    4. Virtual memory space
    5. Physical memory space
    6. Paging
  13. Dynamic Memory Management
    1. Importance of memory management
    2. Memory allocation
    3. Memory freeing
    4. Memory management
    5. Stack and heap allocation
    6. Internal fragmentation
    7. External fragmentation
    8. Compaction
    9. Allocation methods
    10. Splitting and coalescing
    11. Garbage collection 
UNT Outcomes: 
  • Write robust, efficient, readable and correct system software using the C programming language.
  • Demonstrate an understanding of processes and threads by developing applications using multiple processes and multi-threaded activities in a Linux environment.
  • Demonstrate an understanding of deadlocks and synchronization through the development of application(s) that utilize a variety of mutual exclusion mechanisms.
  • Develop shell scripts and utilities that demonstrate an understanding of memory, file and process management and interaction, including concepts such as virtual memory and disk scheduling.
  • Create a Linux-based application that utilizes inter-process communication mechanisms such as pipes and sockets to communicate information between independently running processes on one or multiple platforms.
  • Demonstrate an understanding of the use and interaction among compilers, macro processors, assemblers, linkers and loaders through their use in creating the applications described in previous outcomes.
UNT Department: 
Computer Science and Engineering (CSE)
Course Level: 
Undergraduate
Course Documents: