Programming Paradigms and Scopes

This assignment content discusses various programming paradigms, including variables and scopes. It covers four types of scope: file scope, block scope, function prototype scope, and function scope. The content also touches on Java and Ruby scope, polymorphism, static typing and parsing, generics, abstraction, overriding, inheritance, overloading, concurrency, and transactions.

Programming paradigms
Lecture 14 Variables and scopes
 Pass function to another function, what would be the scope of the
function?
 Four types of scope: file scope, block scope, function prototype scope, and
function scope. Block scope maybe nested
 Java scope- Block scope and class and package scope
 Ruby scope- class definition, module definition, methods. We don’t
declare a type in ruby because it is weakly typed.
COMPARING SCOPES- MIGHT COME IN EXAM
 Shadowing will cause problems because you don’t know which
variable is running, something like that. RESEARCH
 Object oriented language should have three things: inheritance,
encapsulation and polymorphism
 Polymorphism- inheritance is needed to have polymorphism. Static
type should be the super type. Dynamic type is the sub type of the
super type. Ian gave an example of the shape hierarchy.
 Shape S= Circle (..). We cannot declare circle (..) =new shape S
 Look up polymorphism array slide. Polymorphism is also called
dynamic binding.
Lecture: Static typing and parsing
 No information about type is attached to the variable or its value – Weak
typing
 Function/procedure overloading and Operating overloading
 Same name, different signature- Function overloading
 Overriding- inheritance hierarchy
 In dynamic typing, variables do not have assigned types, but types do.
 Duck typing- dynamic typing in ruby. At runtime, a method is called on an
instance of an object. If the instance knows what to do with the method,
then it does it. Otherwise you get an error message.
 In static typing, the compiler makes sure all values have right type for
each method.
 Generics are the way of telling a data structures. E.g. ArrayList list
=newArrayList() – allows any object in the list in OO. Example of the
objects: student id, animals, furniture. As everything is an object in OO.
This is dynamic typing therefore we have to check the list every time we
run the code.
 ArrayList<Duck> list – only allows ducks in the list. Therefore we don’t
have to check the list. Strongly typed.
 Static typing has type interface.
REVISION

 Look at abstract data types
 Abstraction is the process of ignoring small details and focusing on main
stuff
 Revise these topics- OVERRIDING, INHERITANCE, OVERLOADING
 Adding functionality in classes. Class in java is fully abstract.
 Look at java interfaces, fantom mixins, ruby modules and sacala traits.
 Concurrency- two things working at the same time. Deadlock is the result
of synchronise. When things to a point when everything is stopped and
we cant move.
 Live lock- when two processes are trying to do something to be able for
other functions to work. Same result as Deadlock.
 Look at concurrency 3 lecture.
 Google mapreduce- make sure you understand it
 Lost/update problem
 Independent processing- assumptions that we split up the task to make
the process quicker.
 Transaction- Banks lock the account so anyone cant use it something like
that. Used in database as well. Example – a joint bank account has 100
quid. The couple tries to take out 100 quid at the same time.
 Transactions are about keeping track of the version of a variable. It could
be a group of variables. Must avoid side effects.
 Side effects- things that happen as a result. Unintended result.
 Most concurrency is fake. Example: ruby
 Lazy and eager evaluation- most programming language uses eager
evaluation.
 Two types normal and applicative. Normal order is lazy and applicative
order s not.