Programming models

Static vs. Dynamic typing...

is about when type information is acquired (Either at compile time or at runtime).

We can use this type information to detect type errors. A type error is when a value is not of the expected type.

Static type checking

The process of verifying the type safety of a program based on analysis of a program's source code. In other words, type checking happens at compile time, allowing type errors to be detected sooner.

Dynamic type checking

The process of verifying the type safety of a program at runtime. With dynamic type checking, type errors occur at runtime.

Strong vs. Weak typing

vs

Weakly typed

Weak typing means that the type of an construct can change depending on context. For example in a weakly typed language the string "123" may be treated as the number 123 if you add another number to it.

It generally means the type system can be subverted (invalidating any guarantees) because you can cast a value of one type to another.

It's important to note strong vs. weak typing doesn't have a universally agreed on technical meaning. For example, even though Java is statically typed, every time you use reflection or a cast, you are deferring the type check to runtime.

Similarly, most strongly typed languages will still automatically convert between integers and floats. Hence, we should avoid using these terms because calling a type system "strong" or "weak" by itself does not communicate very much.

Mutable vs. Immutable data...

Immutable data

When an object is not modifiable after it has been created. You simply allocate a new value for every change.

vs

Mutable data

When you can modify an object after its creation. When you have a reference to a mutable object, for instance, the contents of the object can change.

Pure vs. Impure functions...

Pure function

A pure function has two qualities:

1) It depends only on the input provided and not on any external state that may change during its evaluation or between calls.

2) It does not cause any semantically observable side effects, such as modifying a global object or a parameter passed by reference.

vs

Impure function

Any function that does not meet the two requirements for a pure function is “impure.”

Lazy vs. Eager evaluation...

Lazy evaluation

Lazy evaluation does not evaluate function arguments unless their values are required to evaluate the function call itself. In other words, expressions are only evaluated when evaluating another expression which is dependent on the current expression. Laziness allows programs to calculate potentially infinite data structures.

vs

Eager evaluation

Eager (or strict) evaluation always fully evaluates function arguments before invoking the function. In other words, an expression is evaluated as soon as it is bound to a variable.

Declarative vs. Imperative...

Imperative

Imperative programming focuses on describing how a program should achieve a result by using statements that specify control flow or state changes. It uses a sequence of statements to compute a result.

vs

Declarative

Declarative programs express a set of operations without revealing how they’re implemented or how data flows through them. It focuses on "what" the program should accomplish (by using expressions to describe the logic) rather than "how" the program should achieve the result.

One example of declarative programming is SQL. SQL queries are composed of statements that describe what the outcome of a query should look like, while abstracting over the internal process for how the data is retrieved:

SELECT EMP_ID, FIRST_NAME, LAST_NAME

FROM EMPLOYEES

WHERE CITY = 'SAN FRANCISCO'

ORDER BY EMP_ID;

Stateful vs. Stateless...

A state is a sequence of values calculated progressively, which contains the intermediate results of a computation.

Stateful

A program which has some mechanism to keep track of and update state. There is memory of the past. Previous transactions are remembered and may affect the current transaction.

vs

Stateless

A program which doesn't keep track of state. There is no memory of the past. Every transaction is performed as if it were being done for the very first time. They give the same response to the same request, function or method call, every time.

Functional vs. Object-Oriented

Functional

A programming paradigm that places a major emphasis on the use of functions. The goal of functional programming is to use functions to abstract control flows and operations on data and to avoid side effects.

Hence, functional programming uses pure functions and avoids mutable data, which in turn provides referential transparency (A function is referential transparent when you can freely replace an expression with its value and not change the behavior of the program - said differently, for a given input, it always return the same results).

Examples of functional languages: Haskell, Lisp, Clojure, Elm

vs

Object Oriented

A programming paradigm that places major emphasis on the use of objects. Programs are made out of objects that interact with one another. These objects can contain data (in the form of fields or attributes) and behavior/logic (in the form of methods).

Object-oriented programs use inheritance as the main mechanism for code reuse. Inheritance means that a new class can be defined in terms of existing classes by specifying just how the new class is different. Polymorphism is also an important mechanism for code reuse in OOP. Polymorphism is when a language can process objects differently depending on their data type or class.

Examples of object-oriented languages: Java, C++, Ruby

Deterministic vs. Nondeterministic

Deterministic

Deterministic programs always return the same result any time they are called with a specific set of input values and given the same state.

vs

Nondeterministic

Nondeterministic programs may return different results each time they are called with a specific set of input values.

Nondeterminism is a property of any concurrent system (A concurrent system is a system where multiple progressing tasks can exist at the same time by running on different threads). A concurrent algorithm that is mutating state may perform differently on different runs depending on which thread the scheduler decides to execute.

Example:

declare X

thread X=1 end

thread X=2 end

The execution order of the two threads is not fixed. We don't know whether X will be bound to 1 or 2. The system will choose during execution and it is free to choose which thread to execute first.

Was this helpful?

(Yay | Nay)

Message me with your thoughts :)

Twitter: @iam_preethi

Email: preethi@preethireddy.com

JavaScript

Thank you!

Object-Oriented JavaScript

JavaScript

Haskell

JavaScript

Elm

vs

JavaScript

Java

Exploring programming models

Preethi Kasireddy