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.
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
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.
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
Loader A piece of software that takes a machine-language program and places it into memory
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
Continue Machine, Assembly, Algorithm, Pseudocode
Elements
Create repository on GitHub, githubusername.github.io, check box to create README
Development
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
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.
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.
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
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]
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.
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
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]