The role of types

• Recall the notion of types.
• Types are useful in catching bugs early:
  1. Incorrect expression evaluation - like dimension mismatch in science.
  2. Incorrect assignment - The value of the expression does not match the type of variable to which the value is stored.

Static vs Dynamic Typing

<aside> 💡 Two approach based on the way in which the type of a variable is determined.

</aside>

• Example: In Python, The type is determined based on the current value - Dynamic typing

  • x=10 → x is of type int
  • x=7.5 → x is of type float

  <aside> 💡 An uninitialized name has no type.

  </aside>

• Static Typing - Associate a type in advance with a name.

  • We need to declare ****names and their types in advance.
  • Like : int a , float x, … → a=7.5 is no longer legal.

We do we need static typing when it is more convenient to use dynamic typing ( Where we don’t need to declare variables in advance)?

Why Static typing?

• In Dynamic typing, catching certain errors(like typos) will be very difficult.

  Example:

  def factors(n):
  	factorlist=[]
  	for i in range(1,n+10:
  		if n%i == 0:
  			factorlst = factorlist + [i]  # There is a typo in this line!!
  	return factorlist
  

  This makes debugging the code difficult.

• Using the notion of Empty User defined objects

  • Linked list is a sequence of objects of type Node
  • How can we represent an empty linked list ( e.g., after deleting all elements in linked list ,etc.)? → Set it be None
  • But in Python ( Which supports Dynamic typing) , the moment you declare the linked list l to None , this variable l will not be associated to any type. i.e., After setting l to None, Python no longer understands that l is a linked list.

Types as organizing concepts

• We can create a new type which can then become “synonyms” of some existing types(or its combination) to help clarify the code.
  • Example:
    • A point in 2D is a pair (float,float) , and a point in 3D is the triple (float,float,float)
    • We can create types with the names point2d and point3d which are the synonyms for (float,float) and (float,float,float) , respectively.
    • Becomes more easier to read and maintain code.
• More Elaborate types give rise to abstract datatypes and enables object oriented programming
  • Consider a banking application.
  • Data and operations are related mostly to accounts, customers, deposits, withdrawals, transfers, etc.
  • We can denote accounts and customers as separate types.
  • Apply object oriented concepts like:
    • Deposits, withdrawal , transfers can be applied to accounts, not customers.
    • Updating personal details applies to customers, not accounts.

Static Analysis

<aside> 💡 Identifying errors as early as possible can save cost and effort.

</aside>

Why?

• Compilers cannot check that a program will work correctly or not → Based on the Halting Problem by Alan Turing.
  • No one can guarantee that the program that they write will work as intended by the consumer of the program.
• So with variable declarations, compilers can detect errors at compile time → Static Analysis
  • Dynamic typing would catch these errors only during the run time of the code.
  • Also, since compiler needs to do simultaneous monitoring for checking the types while running the code, executing the code slows down.