Date post: | 25-Dec-2015 |
Category: |
Documents |
Upload: | hugo-bryant |
View: | 218 times |
Download: | 0 times |
1
APS105
Introduction
2
Welcome
• To University and UofToronto
• To Engineering
• To APS105
3
About your Prof
• Prof. Greg Steffan– PhD Computer Science, Carnegie Mellon, 2003– BASc/MASc, ECE, UofToronto, 1995/1997
• Research– Making multicores and FPGAs easier to program
• Contact:– [email protected]– Office: EA321– Office hours: wed 12-1pm
4
Why Learn About Programming and C?
5
Why Learn Programming?
• Computers: our most powerful technology– Learn to command them to do your bidding!
• For love of design– Programming is pure design with few limitations– “only slightly removed from pure thought-stuff”
• Entrepreneurial opportunities– Start a company in your bedroom with no $$$
• Many engineering jobs involve programming– Simulations, databases, websites– Whether civil, electrical, mechanical…
6
Why Learn C?
• Lots of other newer, sexier languages– Java, Python, Ruby, javascript
• Benefits of C:– “Compiled language”, not “interpreted”
• Close to the hardware with no layers between• Easier to understand what is happening• Important building-block for later computing courses
– C/C++ still very common• In high-performance applications• In low-level code like operating systems, databases,…
– C-like-syntax found in many of above languages
7
Why Attend Lectures?
• To see someone else think through problems– Different than simply seeing the solution
• Learn “why”, not just “how”– how course material fits in with “big picture”
• Will provide proper emphasis– Highlight key material– Overview-only sundry material
• Will teach material in order of importance– Eg., order that you need it for labs
• Ideally more entertaining than reading manual– Else Prof-fail.
8
Administration
9
Course Website
• Portal.utoronto.ca– APS105FALL 2011
• Any Handouts– Lab Assignments– Past Exams– Form for missed labs/quizzes– Form for misgraded midterm
• Discussion Board
10
Course Meetings• Lecture Periods:
– three one-hour lectures per week– Start at 10mins after the hour
• Optional Lecture:– review of regular lecture material– attendance recommended for non-experts– tuesdays 3-4pm MC102 (entire course invited)
• Tutorial Periods:– One per week, run by TAs– Quizes in about half of the tutorials– Attendance optional, unless there is a quiz
• Lab Periods:– Two hours per week– TAs available to answer questions– Attendance "mandatory"
11
Evaluation
• Quizzes: 8%– 4 total– Given in tutorials– Based on lecture material since last quiz
• Labs: 17%– 8 total
• Midterm: 25%• Final Exam: 50%
– Emphasis on 2nd half of course
12
Lecture Slides and Note-Taking
• Electronic slides with fill-in-the-blanks– A hybrid between powerpoint and chalkboard
• Pptx/pdf available on www prior to lecture– Please print and bring to class
• The filled-in “blanks” are only during class– Filled-in slides will not be published
• The symbol that indicates a blank to fill
13
Course Textbook
• “An Introduction to Computer Science Using C”, 2nd Edition– by John Carter– Published by McGraw Hill-Ryerson
• How to get a copy:– UofT bookstore– basement of Sandford Fleming Building– Amazon etc.
14
Labs (programming assignments)
• There are 8 of them in total– You will always be working on one
• Must run properly on ECF systems– Even if it runs fine elsewhere
• Marks for functionality and style– Proper style will be defined throughout term
15
Cheating/Copying
• Easy to do, equally easy to catch!– “cheater-beater” software
• Automatically compares all submissions
– we do actually do this, and do follow through!• the interview and punishment process is painful for all!
• You only cheat yourself– Labs worth 1.6% each– The practice you get by doing them is invaluable– The consequences for being caught are harsh
• See Engineering Calendar for details
16
Getting Help
• See course info handout• Meet some friends: “study groups”
– Collaborating vs cheating
• Ask questions in class– Point out confusing things and mistakes!
• Get help quickly if you get into trouble– First-year office (1st floor Galbraith Building)– www.calss.utoronto.ca
• Help with academics, personal
17
In-Class Etiquette
• Be on time– Class starts at 10mins after the hour
• Quiet please!– Silence yourself and all electronic devices!
• Pay attention– Eg., watching youtube on laptop distracts others
• Ask questions and point out errors!– Raise your hand– Say “question!” if I don’t notice
18
How to Succeed at APS105
• Attend lectures– take notes, ask questions
• Do labs yourself, on-time– Practice/experience is invaluable
• Review lecture material regularly– Be better prepared for quizes/midterm/final– Avoid last-minute cramming
• Prepare for midterm/final– Practice by trying past midterms/finals– Practice by filling lecture slides on your own
• Both available on www
19
How to Succeed at Skule (computing)
• Learn to keyboard properly!• Learn unix/linux basics
– see the unix handout• has details on how to log in from home
• Learn some javascript– For programming www page features
• Write a simple app for your own use– Eg., for your laptop or iphone
20
Computer Systems Basics
21
Computer Systems Stack
ApplicationsJava (and others)Java interpreter (JVM, and others)C (and others) APS105
C CompilerProcessorsLogic gatesTransistorsElectrons and materials
22
How We Tell a Processor What to Do
Programmer Machine Instructions
Add r3,r3,r1Cmp r3,r1Bge 0x3340aMulu r3,r5,r2Sub r1,r3,r4…
intFoo (int x){ return x + 5;}…
Compiler
Processors execute machine instructions encoded in binary
Processor
0100101
23
A TYPICAL PC
Motherboard (CPU, MEMORY)Hard drive
CD/DVD R/W
USB Connectors
Graphics card
Monitor
Keyboard
Mouse
Power Supply
24
Simple View of a Motherboard
Memory (RAM)
CPU
• Memory: – holds bits– can be read from or written to
• CPU: – datapath: arithmetic/logic units (add, sub), etc.– control circuitry
25
C
26
About C
• Invented in Bell Labs (in 1970s)– by Dennis Ritchie– Inherits from earlier language
• called “B”
• C++ – an extension of C– Supports “object oriented programming”
Dennis Ritchie
27
Hello World
.
28
Alternative Hello World
.
29
GCC• gcc
– Means “GNU C compiler”– A program that converts C to 0’s & 1’s
• Stored in a file called an “executable”
• Type this command to compile hello.c
• Generates the executable file
• Insteady you could type:
• Generates the executable file
30
Value Representation
31
Bits and Bytes
• “bit” is short for “binary digit”– A bit can be 0 or 1
• Why do computers use bits?
• A byte is a group of 8 bits– 1 byte can be written as 1B
32
RECALL: BASE 10 (decimal)
• 956
• NOTE: not all languages/cultures use base10– Ndom, Frederik Hendrik Island: base6– nimbia: base12– Huli, Papua New Guinea: base15– Tzotzil, Mexico: base20– Computers use base2 (binary)
33
USING BINARY (BASE 2)
• denoted by ‘0b’ (in this course, in C-code)• Converting from binary to decimal:
• 0b1011
34
Questions
• How many decimal numbers can you represent with N bits?
• NOTE: – computers can only represent finite numbers!
35
Byte Size
• 1byte = 1B = 8bits
36
What is this?
10010010
37
Types
38
Types
• Data Type: – tells computer how to interpret a group of bits– Without a type they are just bits!
• C has types:– Basic data types: built-in, already defined for
you– User-defined types: name your own! (later)
• Basic data types:– A single value of a certain size (bytes)– Example: a number or a character
39
Integer Types
• int: 32bits, values: -231 .. 231-1– We will almost always use int in this class
• Other integer types:– unsigned int: 32bits, values 0.. 232-1– short: at least 16bits– long: at least 32bits– long long: at least 64bits– what does "at least" mean?
• the actual size can depend on the system!!!!!
40
Floating Point Types
• How to use binary to represent real numbers?– Eg., 1.3333333333333….– Can’t: approximate, with limited accuracy
• Floating-point: a common approximation– A value (mantissa) and an exponent– Flexible: can represent very big or very small
• Eg., 2.1313*1020 or 2.1313*10-20
– We don’t need to know the details for this class
41
Floating Point Types in C
• double: at least 64 bits• We will almost always use double in this class
• float: at least 32 bits
42
Character Type
• representing keyboard characters: – Eg: a,b,c,d…A,B,C,D, !@#$%– Standard encoding called ASCII:
• eg., ‘A’ = 65 = 0100 0001 (binary)
• char: 8 bits, typically ASCII-encoded• Note1: char holds only a single character
– How can we represent a “string” of characters?
• Note2: recall “escapes”– Eg., ‘\n’ represents the return character
• Encoded as a single ASCII value
43
Boolean Type
• Often you want to represent true/false– The old way: use int values 0 and 1– The new way: use the bool type
• bool type– Has values ‘true’ and ‘false’– Note: you have to include the bool library
• in program (at top): #include <stdbool.h>
44
Identifiers and Variables
45
Identifiers
• Identifiers give names to things– Choosing good names is a key skill!
• Rules: identifiers can be– any length (any number of characters)– upper & lower case letters, digits, ‘_’– First character cannot be a digit– Cannot match a C “reserved” word (like “int”)
46
Choosing Identifiers: Good Style
• Use upper-case to separate words:
• Or use underscores to separate words:
• Avoid easily-confused characters:
• Choosing good identifiers is an art:
47
Declaring Variables
• Variable: storage of a value of a certain type• Variable declaration:
– specifies that you plan to use a variable– and you would like it to be a certain type– Note: the C-compiler creates storage for it
• General form:
<type> <identifier list>;
48
Declaring Variables: Examples
• Example declarations:
49
Assigning Values
• Can assign a value at declaration, or later• Example assignment at declaration:
• Example assignment at a later point:
• Accuracy:
50
Output
51
Printing to the Screen on PC
Motherboard (CPU, MEMORY)Hard drive
CD/DVD R/W
USB Connectors
Graphics card
Monitor
Keyboard
Mouse Power Supply
.
52
Printing Values
• the printf function prints to the screenprintf(“hi mom\n”);
• printf can also print variable valuesint age = 39;printf(“I am %d years old\n”,age);.
53
Printing Integers
• decimal (base10)– %d: print the decimal using space as necessary– %4d: print the decimal using at least 4 spaces
• Example:.
54
Printing chars
• char– %c: print a single character
• Example:.
55
Printing doubles
• %lf– means “long float” (d is already used!)– by default prints 6 digits right of the decimal– cheat: can use %f instead, does the same thing
• %.2lf– print 2 digits right of the decimal
• %6.2lf– minimum of 6 digits, 2 right of decimal
• %e– use exponent form: ±x.xxxxxxe±nn
56
Printing doubles: Examples
• Examples:.
57
Printing bool
• No conversion specification for bool– Just use %d (decimal)– Prints 0 for false and 1 for true
• Example:.
58
Special Cases
• How do you print ‘%’?– The ‘%’ is the ‘escape’ for conversion specs!– Answer: use ‘%%’
• Example:.
• How do you print ‘\’?– The ‘\’ is also an ‘escape’ character– Answer: use ‘\\’
59
Input
60
Input from the Keyboard
Motherboard (CPU, MEMORY)Hard drive
CD/DVD R/W
USB Connectors
Graphics card
Monitor
Keyboard
Mouse Power Supply
.
61
Input from the Keyboard: scanf
• the scanf function inputs from the keyboard
62
Inputting Multiple Values
• scanf automatically skips whitespace– eg., spaces, tabs, newlines
• .
63
Consuming Whitespace
• If input string is:– “ 22 33 44”
• And I execute:– scanf(“%d%d”,&x,&y);
• The next scanf call would start at this point:– “ 22 33 44”
64
Skipping Characters
• Can manually skip specific characters– eg., non-whitespace– include them in the control string
• Example:.
65
Inputting Chars
• Example:int year;char term;scanf(“%d%c”,&year,&term);
• Note: %c does not skip whitespace!• .
66
Constants
67
Constants
• A constant is a value that does not change– possibly used in multiple places in your program
• Literal constant: – the value is written directly in your code– example: int age = 2;
• named constant:– assign a constant value an identifier– then use the identifier in your code– Named constants make for easier-to-read code!
68
Named Constants Example
• With literal constant:.
• With named constant:.
69
Two Methods for Named Constants
• Using the const attribute– General form:
const <type> <identifier> = <value>;
const double PI = 3.14159;– const attribute promises value will not change
• Using the #define compiler directive#define PI 3.14159– note1: directives go at top of file– note2: directives have no ‘=‘, no ‘;’– compiler does a search-and-replace of PI
• with the value 3.14159 everywhere PI appears
70
Named Constants for Good Style
• avoid magic numbers in your code– numbers which have no meaning to others– use of magic numbers will cost you points in labs!
• avoid multiple copies of the same value– if you must update the value, only have to do it in
one place in the code
• Convention/Good-Style:– use capital letters for named constant identifiers– eg., PI and MAX_ATTEMPTS