Programming Languages Concepts: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
Line 34: Line 34:
<span id='Strong_Typing'></span>In a '''strong typed''' language the type of an instance does not change, even if the value is mutable.
<span id='Strong_Typing'></span>In a '''strong typed''' language the type of an instance does not change, even if the value is mutable.


[[Python_Language#Type|Python]] and Go are strongly typed languages.
[[Python_Language#Type|Python]] and [[Go_Language#Type|Go]] are strongly typed languages.


==Type Safety==
==Type Safety==

Revision as of 22:13, 14 August 2023

External

Internal

Statement

Expression

Typing

Type

A type determines the set of values and operations specific to values of that type, and the way the instances of the type are stored in memory - the size of the values. Expressions of a certain type (variables, functions) take their values from the type's set of values.

Static Typing vs Dynamic Typing

For a statically typed system, the variables and expressions always have a specific type, and that type cannot be changed. This is where "static" comes from: a variable will always have the same type. The type is known at compile-time. The compiler uses this information to catch some classes of errors at compile time and produce low-level machine language that typically runs faster. C, C++, Java and Go are statically typed languages, and much of the code written in such language is used to declare types.

Dynamically typed languages are convenient, because there are no intermediate steps between writing the code and executing it. A dynamically typed language, also called a scripting language, do not forces the programmer to declare the type of a variable before using them. Dynamic languages are not compiled, but interpreted. However certain types of errors cannot be caught until the program executes. For statically typed languages, many of these errors are caught at the compilation phase. On the downside, static languages usually comes with a great deal of ceremony around everything that happens in the program (heavy syntax, type annotations, complex type hierarchies). Python is a dynamically typed language.

Strong Typing vs Loose Typing

In a strong typed language the type of an instance does not change, even if the value is mutable.

Python and Go are strongly typed languages.

Type Safety

https://en.wikipedia.org/wiki/Type_safety

Type safety is the extent to which a programming language discourages or prevents type errors. Type enforcement can be static, exercised at compile-time, or dynamic, associated type information with values and detecting type errors at run-time, or both. Java and C# are examples of type-safe languages.

Type Systems

The Go Type System
The JavaScript Type System

Scoping

Static and dynamic scoping: https://www.geeksforgeeks.org/static-and-dynamic-scoping/

Duck Typing

Polymorphism

Polymorphism is a feature of a programming language allowing to write code that behaves differently depending on the runtime state at a specific moment in time. The contract of the behavior is defined by an interface, while the implementation of the interface can vary. In Java, different classes may implement an interface, and instances of those classes can be used interchangeably as that interface. In Go, different concrete types implement an interface.

Interfaces in Go

Metaprogramming

Metaprogramming is writing code that manipulates other code, or even itself.

Object-Oriented Programming

Object-Oriented Programming

Functional Programming

Functional Programming

Concurrent Programming

Concurrent Programming

Formal Languages and Translators

Formal Languages and Translators

Number Representation in Computers

Number Redpresentation in Computers

Domain Specific Languages (DSL)

Domain Specific Languages