Plagiarism in University

Copying code from others is wrong because:

• you do not learn
• you risk being expelled
• you are risking the other person being expelled
• you risk not completing your degree
• you risk being put on a list of cheaters (other universities may reject your application)

Plagiarism in the Industry

Is wrong, because:

• it is illegal
• you risk being dismissed from employment
• you risk being sued

Copying code (when it is right)

• software licenses define clear rules on
  how you can copy, use, and change other people's code

• open source promotes sharing of code

  • attribution is important (unless public domain)
  • good way to land a job

Plagiarism in CS 450

• student's responsibility to learn the Student's code of conduct
• we use plagiarism detection (renaming functions is not enough)
• we compare against solutions from past years (and instructor)
• be careful when working with others, any code sharing may trigger it
• the plagiarism detection tool can detect code sharing among students

Evaluating a function call

Evaluation works from left-to-right from top-to-bottom

#racket lang
*; Version 1:
(* 3.14159 (* 10 10))
*; Version 2:
(* 3.14159 100)
;          ^^^- Evaluated (* 10 10)
*; Version 3:
314.159
;^^^^^^- Evaluated (* 3.14159 100)

Evaluating a function call

Evaluation works from left-to-right from top-to-bottom

#racket lang
*; Version 1:
(* 3.14159 (* 10 10))
*; Version 2:
(* 3.14159 100)
;          ^^^- Evaluated (* 10 10)
*; Version 3:
314.159
;^^^^^^- Evaluated (* 3.14159 100)

Arithmetic expressions example

Arithmetic expressions example

(+
  (+
    (* 11 15)
    (+ 14 4))
  (-
    (/ 3  9)
    (* 14 3)))

A longer example

(+
  (+
*   (* 11 15)
    (+ 14 4))
  (-
    (/ 3  9)
    (* 14 3)))

(+
  (+
    165
*   (+ 14 4))
  (-
    (/ 3  9)
    (* 14 3)))

(+
* (+
*   165
*   18)
  (-
    (/ 3  9)
    (* 14 3)))

(+
  183
  (-
*   (/ 3  9)
    (* 14 3)))

Interpreting an error in Racket

What would happen if we call a function using the infix notation?

(3 / 9)

Is this example a legal Racket program?

#lang racket
sin

Racket specification

Values

• Numbers
• Void
• Booleans
• Lists
• …

Boolean, numeric comparisons

• False: #f
• True: anything that is not #f
• Logical negation: function (not e) negates the boolean result of expression e
• Numeric comparisons: <, >, <=, >=, =

To avoid subtle bugs, avoid using non-#t and non-#f values as true. In particular, contrary to C the number 0 corresponds to true. Tip: There is no numeric inequality operator. Instead, use (not (= x y))

Logical and/or

• Logical-and with short-circuit: and (0 or more arguments, 0-arguments yield #t)
• Logical-or with short-circuit: or (0 or more arguments, 0-arguments yield #f)

Boolean examples

Operations and/or accept multiple parameters. Rectangle intersection:

(and (< a-left b-right)
     (> a-right b-left)
     (> a-top b-bottom)
     (< a-bottom b-top))

As an example of short-circuit logic, the expression

(or #t (f x y z))

evaluates to #t and does not evaluate (f x y z). Recall that and also short-circuits.

Branching with cond

cond evaluates each branch sequentially until the first branch's condition evaluates to true.

Example

If x is greater than 3 returns 100, otherwise if x is between 1 and 3 returns 200, otherwise returns 300:

(cond [(> x 3) 100]
      [(> x 1) 200]
      [else 300])

Variable definition

A definition binds a variable to the result of evaluating an expression down to a value.

Examples

#lang racket
(define pi 3.14159)
pi
(* pi 2)

$ racket def-val.rkt
3.14159
6.28318

Revisiting the language specification

A program consists of zero or more terms.

A term is either an expression or a definition.

Void

Definitions evaluate to #<void>, which is the only value that is not printed to the screen.

(define pi 3.14159)      <-- A definition evaluates to --> #<void>

The void value cannot be created directly. Another way of getting a void value #<void> is by calling function (void).

Try running this program and confirm that its output is empty:

#lang racket
(void)

Evaluating variable definition

When we execute a Racket program, we have an environment to bookkeep each variable, that is a map from variable names to values.

*(define pi 3.14159)
(* pi 2)

; pi = 3.14159
*#<void>
;^^^^^- Eval define
(* pi 2)

; pi = 3.14159
*; Prints #<void>
*(* pi 2)

Do variables evaluate?

Variables are considered expressions, so the runtime must look up the value bound to a variable as one step of the evaluation.

Beware of re-definitions

The following is legal Racket code:

#lang racket
(define pi 3.14159)
(* pi 2)
(define + #f)
(+ pi 2)

• Redefinitions produce subtle side-effects and may void existing assumptions
• As we will see, redefinitions also complicate the semantics and code analysis

Exercise: conditionals

• The modulo operator (%) in Racket is function modulo
• The equality operator in Racket is equal?

Translate the following code to Racket:

n = 16
if n % 15 == 0:
    return "fizzbuzz"
if n % 3 == 0:
    return "fizz"
if n % 5 == 0:
    return "buzz"
return n

Exercise: conditionals (solution)

(define n 16)
(cond [(equal? (modulo n 15) 0) "fizzbuzz"]
      [(equal? (modulo n 3) 0) "fizz"]
      [(equal? (modulo n 5) 0) "buzz"]
      [else n])

Exercise: evaluation

#| How many evaluation steps should we expect? |#
(define x (* 10 2))
(+ x (* 4 2))

Solution

Function declaration

A function declaration creates an anonymous function and consists of:

• parameters: zero or more parameters (identifiers, known as symbols)
• body which consists of one or more terms

When calling a function we replace each parameter defined in the lambda by the corresponding argument. If the number of arguments is not the expected one, then we get an error. The return value of the function corresponds to the evaluation of the last term in the body (known as the tail position).

We can define circumference as a function and parameterize the radius:

#lang racket
(define circumference (lambda (radius) (* 2 3.14159 radius)))
(circumference 2)

$ racket func.rkt
12.56636

Evaluating a lambda

(define circ
 (lambda (radius) (* 2 3.14159 radius)))
(circ 2)

; circ = lambda ...
#<void>
;^^^^^- Eval define
(circ 2)

; circ = lambda ...
; Prints #<void>
(circ 2)

; circ = lambda ...
((lambda (radius) (* 2 3.14159 radius)) 2)
;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- Subst circ

; circ = lambda ...
(* 2 3.14159 2)
;^^^^^^^^^^^^^^- Applied func

; circ = lambda ...
12.56636

; circ = lambda ...
; Prints 12.56636

For more information on evaluation, read Section 1.1.5 of SICP.

Function definition

#lang racket
(define (circumference radius)
  (* 2 3.14159 radius)))
(circumference 2)

Exercise

The McCarthy 91 function was invented by computer scientist John McCarthy to motivate formal verification.

• Implement the function in Racket
• What is $M(99)$?

Template excerpt

The homework template is in our Directory page:

(define ex1 'todo)
(define ex2 'todo)
(define ex3 'todo)

;; ...