comparative

Question 1

imperative programming

Answer 1

the programmer
gives an explicit sequence of steps which
are done in order. (e.g. C++, Python, PHP,
Rust)

Question 2

declarative

Answer 2

the
programmer describes the result they
need, and the language/compiler decides
how to best produce it. (e.g. Haskell)

Question 3

high vs low level

Answer 3

Higher-level: more like what people want to
write/understand. (e.g. Python, Haskell)
Lower-level: more like what the computer
understands/executes. (e.g. assembly, C

Question 4

is an interpreter purely interpreting code?

Answer 4

Most programs that appear to be interpreters
are actually both a compiler and interpreter.

Question 5

what does a virtual machine represent

Answer 5

a virtual machine is an
interpreter for bytecode.

Question 6

what are the pros for JIT

Answer 6

optimize machine code for the specific CPU architecture (e.g. Skylake vs generic x86);
collect usage stats and optimize output for the way code is actually being used;
create type-specific versions of functions for the types of arguments they actually receive (see “dynamic binding” , later).

Question 7

what is JIT

Answer 7

Interpreting (byte)code at run-time always comes with a speed penalty. Even the most clever bytecode needs to be somehow processed while it’s running: that takes instructions and therefore time.
A Just-In-Time compiler starts with bytecode and either…
1. interprets but when it decides that some piece of logic will be used frequently, it…
2. for all code… … during execution, compiles that code to machine code and stores it in memory.
Then, when that code needs to execute (again), it can use the machine code version.

Question 8

cons of JIT

Answer 8

But, JITs have to do their work during program execution. That will slow things down (at least momentarily). Performance may be less predictable.

Question 9

are languages restricted to a specifc compilation method?

Answer 9

Any programming language*
could be compiled to machine
code, or to a VM, or interpreted
directly.

Question 10

A question: does the compiler know a variable or value’s type when it compiles the program?

Answer 10

For statically typed languages, the answer is yes: C, Java, C#, Dart, etc.
Where the types aren’t known until runtime, the language is dynamically typed: Python, JavaScript, Lisp, Ruby, etc.

Question 11

pros of statically typed langauges

Answer 11

Static:
In a statically typed language, you can have more confidence that the types are right.

Question 12

pros an cons for dynamic typed langauges:

Answer 12

Dynamic:
Pros:
Dynamic typing allows more flexibility and often less code. The programmer doesn’t have to explicitly declare/allocate/type variables, which saves keystrokes/effort.
Cons:
types must be checked every time a line of code is executed.

Question 13

what are 3 things that always have to be checked at run time

Answer 13

there are some related things that always have to be checked at runtime: array bounds, division by zero, overflow, etc.

Question 14

what is gradual typing definition

Answer 14

where values/ variables can be given static types that can be checked at compile-time, but it’s optional.

Question 15

when do we know which operation has to be applied for:
static
dynamic

Answer 15

Statically bound:
the compiler knows exactly which operation is going to happen.
Java
Dynamically bound:
the details have to be determined at run-time
Pyhton

Question 16

benefit of static and cons to dynamic when applying (add) operator

Answer 16

executing the processor’s ADD instruction
a type check, symbol table lookup (__add__), method call, then do the ADD.

Question 17

major drawback to python

Answer 17

Standard python code compiles to byte code
Python is slow not because it is interpreted (compiled to byte), but it is slow because of dynamic binding

Question 18

describe JIT with if else statement

Answer 18

if types match previous calls:
call statically-typed machine code
else:
interpret dynamically-typed bytecode,
or maybe compile a version for the new types.

Maybe you get a statically-typed implementation of your dynamically-typed code.

Question 19

when does a static typed code run dynamically

Answer 19

polymorphism on java, but not on C++

Question 20

what type in Haskell is an example of a Generic

Answer 20

This will work on any arguments in the Eq typeclass, and Haskell can statically-compile any specialized version it needs.

Question 21

what is the purpose of type inference

Answer 21

If the compiler can infer types, it can statically bind in its output.

Question 22

strongly typed definition

Answer 22

every value has a single well-defined type, so you can do lots of checking.

Question 23

weakly typed definition

Answer 23

single values can be treated as different types, so type checking is harder.

Question 24

how to get away with strongly typed

Answer 24

pointer casting

C and Java are mostly strongly typed since values are explicitly statically typed, but pointer/​reference casting allows the programmer to do weakly-typed things.

Question 25

what is an example of strongly typed in a langauge

Answer 25

Python is strongly typed since the type of each value is tracked by the language (but at runtime since it’s dynamically typed).

Question 26

places where imutable might be importatn

Answer 26

In a dictionary/​map/​hash table key: the data structure needs to be able to check the value when it’s inserted and know it doesn’t change while in the collection. (e.g. it always has the same hash value)
As an argument: a mutable object could be modified whenever it is given as an argument to a function. Immutability ensures it won’t be.
Sharing between threads: safe for multiple threads to access it if it can’t be changed.

Question 27

places where mutable is important`

Answer 27

Collections: don’t want to rebuild a list of a million elements just to add one more.
State: state of a game (or whatever) changes frequently and could be shared by many parts of the code.
We want to pass an object to a function and have it modified.

`

Question 28

what is static, heap and stack memory

Answer 28

Static: memory known to be needed at compile time. e.g. strings in in the program, globals, C static.
Stack: function parameters and functionlocal variables (or similar for other variables scopes).
Heap: dynamically-allocated objects. e.g. malloc in C; new in C++, Java, C#; all objects in Python, Ruby

Question 29

what type of memory does dynamic uses the most

Answer 29

In dynamic languages, usually everything is on the heap (but there is a call stack for functions).

Question 30

what are the two ways for garbage collection

Answer 30

Reference counting and tracing

Question 31

what is reference counting and when can it be checked

Answer 31

garbage collection keeps track of the number of references to each object. When the number decreases to zero, delete. Can’t handle cyclic data structures; requires space and time to maintain the counters.
C++ example:
Assuming we keep the unique_ptr on the stack, it will be deleted as appropriate. When the unique_ptr is deleted, it will automatically delete the object it refers to: the pointer was unique, so “reference counting” is easy and can be done at compile-time

Question 32

what is tracing

Answer 32

garbage collection looks for which objects are reachable from references available in the program: everything else is garbage. There are many strategies to do this quickly and without stopping execution while it happen

Question 33

what is a finalizer

Answer 33

A garbage collector is part of a language’s runtime environment that looks for objects on the heap that can no longer be accessed (garbage) an frees them (after calling their finalizers, in languages that have the concept).

Question 34

what are the 3 types of tracking heap ownership

Answer 34

Manual memory management
Run-time garbage collection
Compile time ownership tracking

Question 35

what is concurrent programming

Answer 35

A concurrent program is one where several parts of the program are running together (possibly taking turns, or possibly on different cores).

Question 36

what is parallel programming

Answer 36

A parallel program is a concurrent program where different processes or (kernel) threads allow different parts of the code to run at the same time on multiple cores.

Question 37

what is a process

Answer 37

an instance of a running program.

Question 38

what is a thread

Answer 38

A single process can have several points where it is executing concurrently: each is a thread.

Question 39

what is thread safe

Answer 39

is thread safe if it can be used by multiple concurrent threads without anything going wrong.