Module 5

Low Level Programming

Chapter 6 is about programming!

Chapters 2 and 3 were about the basic information necessary for understanding a computing system, including number systems and ways to represent different types of information in a computer.

Chapters 4 and 5 were about the hardware components of a computer.

Now the emphasis changes from what a computer system is to how to use one.

Outline Chapter 6

Chapter 6 Low-Level Programming Languages and Pseudocode

6.1 Computer Operations

6.2 Machine Language

Pep/8: A Virtual Computer

6.3 A Program Example

Hand Simulation

Pep/8 Simulator

6.4 Assembly Language

Pep/8 Assembly Language

Assembler Directives

Assembly-Language Version of Program Hello

A New Program

A Program with Branching

A Program with a Loop

6.5 Expressing Algorithms

Pseudocode Functionality

Following a Pseudocode Algorithm

Writing a Pseudocode Algorithm

Translating a Pseudocode Algorithm

6.6 Testing

Ethical Issues: Software Piracy

Related FGCU Courses

http://icarus.fgcu.edu:8080/CourseDescriptions/

COP 3530 Data Structures & Algorithms

Data structure design, implementation, application, and analysis are explored. Abstract data types (ADTs) are introduced and uses of interfaces is emphasized. Topics include stacks, queues, linked lists, and trees. Recursion is revisited, the O notation is introduced, and computational complexity of searching and sorting algorithms are explored.

https://www.fgcu.edu/eng/softwareengineering/softwareengineering-bs.aspx#CurriculumMap

Lesson

Day One

Chapter questions review
Machine language -> Assembly language -> Pseudocode -> High level code
Machine language - the language made up of binary-coded instructions that is used directly by the computer
- Pep/8
  - A register is a small area of storage in the ALU of the CPU that holds special data and intermediate values. Pep/8 has seven registers, three of which we focus on at this point:
    - The program counter (PC) contains the address of the next instruction to be executed
    - The instruction register (IR) contains a copy of the instruction being executed
    - The accumulator (A register) stores arithmetic and logic results
  - Two parts to an instruction:
    - the instruction specifier - 8 bits, indicates which operation is to be carried out
      - opcode
      - addressing mode specifier
        immediate (operand is data)
        direct (operand is address of data)
    - the operand specifier (optional) - 16 bits, holds either the operand itself or the address of where the operand is to be found
  - Basic operation
  - Program decoded
    - Hexadecimal to Binary Converter
- Loader A piece of software that takes a machine-language program and places it into memory

Day Two

Assembly language - a language in which we can use a combination of letters to represent a machine-language instruction.
- Look at and modify fig0526
Algorithm - A plan or outline of a solution; a logical sequence of steps that solve a problem
Pseudocode - A language designed to express algorithms
- Write a pseudocode algorithm to get three integers from the user and print them in numeric order.
Related games that will help prepare you for Assembly Language class
- SHENZHEN IO - successor to TIS 100
- TIS 100 - minimal, originally a mini-game
- 7 Billion Humans - successor to Human Resource Machine
- Human Resource Machine
Continue Machine, Assembly, Algorithm, Pseudocode

Project Review

HTML

Elements
Create repository on GitHub, githubusername.github.io, check box to create README
Shortest (useful) HTML5 Document
Development
- Notepad++
- Sublime Text
- Brackets
  - Getting Started video

Project Preview

CSS

w3schools CSS HOME - How To, Position, Overflow, Float
Syntax and Selectors IMPORTANT!
- class - period (like in school, many students)
- id - number sign (you have one unique id number)
inline
external file
CSS Jokes

Software Development Fundamentals (SDF)

Fluency in the process of software development is a prerequisite to the study of most of computer science. In order to use computers to solve problems effectively, students must be competent at reading and writing programs in multiple programming languages. Beyond programming skills, however, they must be able to design and analyze algorithms, select appropriate paradigms, and utilize modern development and testing tools. This knowledge area brings together those fundamental concepts and skills related to the software development process. As such, it provides a foundation for other software-oriented knowledge areas, most notably Programming Languages, Algorithms and Complexity, and Software Engineering.

Algorithms and Design

This unit builds the foundation for core concepts in the Algorithms and Complexity Knowledge Area, most notably in the Basic Analysis and Algorithmic Strategies knowledge units.

KA Topics:

The concept and properties of algorithms
- Informal comparison of algorithm efficiency (e.g., operation counts)
The role of algorithms in the problem-solving process
Problem-solving strategies
- Iterative and recursive mathematical functions
- Iterative and recursive traversal of data structures
- Divide-and-conquer strategies
Fundamental design concepts and principles
- Abstraction
- Program decomposition
- Encapsulation and information hiding
- Separation of behavior and implementation

KA Learning Outcomes:

Discuss the importance of algorithms in the problem-solving process. [Familiarity]
Discuss how a problem may be solved by multiple algorithms, each with different properties. [Familiarity]
Create algorithms for solving simple problems. [Usage]
Use a programming language to implement, test, and debug algorithms for solving simple problems. [Usage]
Implement, test, and debug simple recursive functions and procedures. [Usage]
Determine whether a recursive or iterative solution is most appropriate for a problem. [Assessment]
Implement a divide-and-conquer algorithm for solving a problem. [Usage]
Apply the techniques of decomposition to break a program into smaller pieces. [Usage]
Identify the data components and behaviors of multiple abstract data types. [Usage]
Implement a coherent abstract data type, with loose coupling between components and behaviors. [Usage]
Identify the relative strengths and weaknesses among multiple designs or implementations for a problem. [Assessment]

Fundamental Programming Concepts

This knowledge unit builds the foundation for core concepts in the Programming Languages Knowledge Area, most notably in the paradigm-specific units: Object-Oriented Programming, Functional Programming, and Event-Driven & Reactive Programming.

KA Topics:

Basic syntax and semantics of a higher-level language
Variables and primitive data types (e.g., numbers, characters, Booleans)
Expressions and assignments
Simple I/O including file I/O
Conditional and iterative control structures
Functions and parameter passing
The concept of recursion

KA Learning Outcomes:

Analyze and explain the behavior of simple programs involving the fundamental programming constructs variables, expressions, assignments, I/O, control constructs, functions, parameter passing, and recursion. [Assessment]
Identify and describe uses of primitive data types. [Familiarity]
Write programs that use primitive data types. [Usage]
Modify and expand short programs that use standard conditional and iterative control structures and functions. [Usage]
Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: basic computation, simple I/O, standard conditional and iterative structures, the definition of functions, and parameter passing. [Usage]
Write a program that uses file I/O to provide persistence across multiple executions. [Usage]
Choose appropriate conditional and iteration constructs for a given programming task. [Assessment]
Describe the concept of recursion and give examples of its use. [Familiarity]
Identify the base case and the general case of a recursively-defined problem. [Assessment]