INTRODUCTION TO

SYSTEM PROGRAMMING
 CONTENT
• SYSTEM PROGRAMMING

• SYSTEM SOFTWARE

• COMPONENTS OF
SYSTEM SOFTWARE

• ASSEMBLER

• LOADER

• PREPROCESSOR

• COMPILER
 SYSTEM PROGRAMMING
• System programming is the activity of
programming system software. The primary
distinguishing characteristic of systems
programming when compared to
application programming is that application
programming aims to produce software
which provides services to the user. whereas
systems programming aims to produce
software which provides services to the
computer hardware .
 SYSTEM SOFTWARE
• What is System Software?
• System software is closely related to, but
distinct from Operating System software. It is
any computer software that provides the
infrastructure over which programs can operate,
ie it manages and controls computer hardware
so that application software can perform.
Operating systems, such as Microsoft Windows,
Mac OS X or Linux, are prominent examples of
system software
 COMPONENTS
• ASSEMBLER

• LOADER

• PRE-PROCESSOR

• LOADER/LINKER
 PRE-PROCESSOR
• In computer science, a preprocessor is a program
that processes its input data to produce output that
is used as input to another program. The output is
said to be a preprocessed form of the input data,
which is often used by some subsequent programs
like compilers. The amount and kind of processing
done depends on the nature of the preprocessor;
some preprocessors are only capable of performing
relatively simple textual substitutions and macro
expansions, while others have the power of fully-
fledged programming languages.
 COMPILER
• A compiler is a computer program (or set of programs) that
transforms source code written in a computer language (the
source language) into another computer language (the
target language, often having a binary form known as
object code). The most common reason for wanting to
transform source code is to create an executable program.
• The name "compiler" is primarily used for programs that
translate source code from a
high-level programming language to a lower level language
(e.g., assembly language or machine language). A program
that translates from a low level language to a higher level
one is a decompiler. A program that translates between
high-level languages is usually called a language translator,
source to source translator, or language converter.
 ASSEMBLER
• A utility program called an assembler is used to
translate assembly language statements into the
target computer's machine code. The assembler
performs a more or less translation (a one-to-one
mapping) from mnemonic statements into machine
instructions and data. (This is in contrast with
high-level languages, in which a single statement
generally results in many machine instructions.)
• Many sophisticated assemblers offer additional
mechanisms to facilitate program development,
control the assembly process, and aid debugging. In
particular, most modern assemblers (although many
have been available for more than 40 years already)
include a macro facility (described below), and are
called macro assemblers
 ASSEMBLY LANGUAGE STATEMENTS

• IMPERATIVE STATEMENTS

• DECLARATIVE STATEMENTS

• ASSEMBLER DIRECTIVE
 LOADER
• Loader is the part of an operating system that is
responsible for loading programs from executables (i.e.,
executable files) into memory, preparing them for
execution and then executing them.
• The loader is usually a part of the operating system's
kernel and usually loaded at system boot time and stays
in memory until the system is rebooted, shut down, or
powered off. Some operating systems that have a
pageable kernel may have the loader in the pageable part
of memory and thus the loader sometimes may be
swapped out of memory. All operating systems that
support program loading have loaders. Some embedded
operating systems in highly specialized computers run
only one program and have no program loading
capabilities and thus no loaders, for example embedded
systems in cars or stereo equipment.
 RESPONSIBILITIES
• validation (permissions, memory
requirements etc.);
• copying the program image from the disk
into main memory;
• copying the command-line arguments on
the stack;
• initializing registers (e.g., the stack
pointer);
• jumping to the program entry point (_start).