WELCOME TO
                COP 3402
             SYSTEMS SOFTWARE

Professor Gary T. Leavens
          329 L3 Harris Center

Phone:  (407)823-4758
Email:  Leavens@ucf.edu

Office Hours: Tuesdays and Thursdays, noon-1:30 PM

COURSE INFO:
   Webcourses@UCF
   www.cs.ucf.edu/~leavens/COP3402


        THINGS TO THINK ABOUT

HW0 due Friday at 11:59 PM

Think about forming a group of 2 or 3
   students (in this lecture section)
   for team projects.

            PREREQUISITES

From the UCF Catalog:

"CDA 3103C and
 COP 3502C
each with a grade of "C" (2.0)
                     or better."

          SYSTEMS SOFTWARE

def: *systems software*:
    enables running programs on a computer





          SOME DEFINITIONS

def: A *compiler* translates a programming
language into a form that can be executed
(easily) by a computer

def: An *interpreter* executes a program
directly without first translating it.
Now interpreters translate to a
virtual machine (VM) language (byte code),
like the Java VM, and the VM executes
that byte code.

def: An *assembler* translates a low-level
language into machine code.

Assembly languages typically have
no structure.







           SOME HISTORY

Computers essential for modern life
   (e.g., check clearing)

Nearly impossible for humans to program
   in machine code

Assembly language called "auto coding"

Subroutines and libraries
  allowed expertise to be codified
  
High-level langauges (FORTRAN, COBOL)
  (about 1957) needed considerable effort

Algol 60, Algol 68
  showed difficulty of implementation

Various advances made compilers possible:
   - formal language theory
       - regular grammars
       - context-free grammars
   - syntax-directed translation
   - symbol tables and static analysis
   - linkers, loaders

               LINKERS

def: A *linker* combines parts of a program
into a single executable file,
resolves names (e.g., for library functions)

def: A *loader* puts an object file
into memory, so it can be executed




def: A tool's work is *static* if it
can work before running the program, always.

A tool's work is *dynamic* if it needs to
run the program, in general.





 OTHER TOOLS RELATED TO OPERATING SYSTEMS

def: A *loader* puts an object file
into memory, so it can be executed


def: A *debugger* allows the state
of a running program to be investigated

 e.g., Visual Studio's debugger
       lldb, Valgrind, gdb (adb)


def: An *operating system* is a program
that manages a computer's resources.
It provides abstractions of them, security,
and sharing of resources.





           COURSE OBJECTIVES

- Explain and correctly use the concepts
  behind software tools and their design
  and their role in an operating system (OS)


- Implement, as part of a team,
  a compiler


- Evaluate, as part of a team,
  the quality of a tool's implementation


Why?
  + It's essential for developers

  + Increase your software engineering
    skills

  + Techniques are useful for developing
    other software tools







           LEARNING OUTCOMES

By the end of the course you
will be able to:

- Use Concepts related to systems software

- Build systems software in a team

- Appraise the quality of software
  implementations




           PLAN FOR THE COURSE

Broad outline:

   Virtual Machines
   
   Compilers
      - Lexical analysis
      - Syntax analysis
      - Code generation

   OS
      - interupts
      - processes and threads

 

         GRADING AND FINAL GRADES

+ No curve grading

+ Your final grade is based on:

     41% project (homeworks)
     23% midterm exam
     31% final exam
      5% recitations


           TEXTBOOKS

Recommended:

Systems Software: Essential Concepts,
by Euripides Montagne, Cognella,
Cognella Academic Publishing, 2021.

Compilers: Principles, Techniques,
and Tools (2nd edition)
by Alfred V. Aho, Monica S. Lam,
Jeffrey D. Ullman, and Ravi Sethi,
Pearson, 2007.

Engineering A Compiler (2nd edition)
by Keith D. Cooper and Linda Torczon,
‎Morgan Kaufmann, 2011.

Modern Compiler Implementation in Java
(2nd edition)
by Andrew W. Appel and Jens Palsberg,
Cambridge University Press, 2002.

        COOPERATION

Can talk with others about homework
  - but must cite:
      - people on different teams
      - other sources


         CHEATING

Exchange of finished answers outside team
  - without cooperation in solving them
  - without certification

Using ideas of others
  - without citation

Copying answers from the web
  - without citation