Dynamic Typing Is Fun, Until It Isn’t (Lessons from Python and C#)

As an undergraduate in Software Engineering, I began my programming journey with Python. Its basic simplicity, ease of use, flexibility and versatility made it easy for an amateur like me to understand the complex with less complexity. Python’s dynamic typing and concise syntax allowed me to write programmes quickly, experiment with different approaches and focus on solving problems. But when I started learning C#, I had to deal with a whole new level of static typing which completely changed my approach to coding. With that being said, having learnt python with a language-agnostic slant, the transition was not difficult; rather it was novel.

To learn more about my language-independent coding, read my article here.

To learn more about my language-independent coding, read my article here.

In this article, I will explain how learning C# after Python made me appreciate the benefits of static typing, and how it improved my coding practices thus making my code reliable and easier to maintain.

Both static typing and dynamic typing refer to how programming languages handle variable types. But they differ in when type checking occurs.

In static typing the type of any given variable is known at compile-time (this refers to the phase when the source code is translated into the bytecode). That means you must define the type of each variable when you declare it. Should there be a type mismatch the compiler catches the error before the programme is executed and throws a compile-time error.

In contrast, Python is dynamically typed, meaning that the type of variable is determined at runtime (refers to when the bytecode is being executed). Definition of variable type is not needed upon declaration as the interpreter checks the types as the code is executed.

Let’s explore the differences using a few code examples.

Python — Dynamic typing

x = 10
print(x)
x = "Hello world!" 
print(x)

Python, being very flexible, has no constraints on variable types. As in the above example, you can assign an integer value to a variable and later change it to a string without any sort of error being returned. While this is great for quality prototyping, this can also lead to unexpected bugs during runtime.

C# — Static typing

int x = 10;
Console.WriteLine(x);
x = "Hello, world!";  // Error
Console.WriteLine(x);

In C#, type mismatch is immediately identified by the compiler and an error is thrown, should you attempt to assign an integer to a string variable. This prevents runtime type errors making your code more predictable and cleaner.

Both Python and C# provide structures to capture multiple values with varying implementation strategies and type checking.

Python Lists (dynamic)

my_list = [1, "Hello", 3.14]
print(my_list)

In Python, you can store different types of data in the same list without issues. While this increases flexibility, you are at a disadvantage because you do not know the types of elements ahead of time.

C# Arrays (static)

int[] myArray = {1, 2, 3};

Here, myArray is an integer array and you cannot assign a string to one of its elements. This guarantees that the array will only contain integers, and any operations done on it will be type-safe (meaning that the compiler ensures operations are performed only on compatible types).

Dynamic typing in classes using Python

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

dog = Animal("Dog")
dog.speak()

Python allows you to create classes without explicitly defining types for properties, making it easier to work with but harder to detect errors.

Static typing in classes using C#

class Animal
{
    public string Name { get; set; }

    public Animal(string name)
    {
        Name = name;
    }

    public void Speak()
    {
        Console.WriteLine($"{Name} makes a sound.");
    }
}

Animal dog = new Animal("Dog");
dog.Speak();

In C#, properties like Name have clearly defined types (string), and the compiler will enforce these types throughout the code. This makes the code more robust (meaning that the code is strong, resilient and able to handle unexpected inputs without crashing) and less prone to runtime errors.

1) Early error detection

Static typing helps you catch errors early in the development process and with languages like C#, the compiler ensures that you are working with correct types, preventing many common mistakes that might only surface at runtime in dynamically typed languages like Python.

void PrintSum(int a, int b)
{
    Console.WriteLine(a + b);
}

PrintSum(10, "20");  // Error

As shown above, the C# compiler will immediately flag the error because you are trying to pass a string to a method that expects an integer.

2) Code clarity and readability

With static typing, the data types are explicit, which makes the code more predictable and easier to understand. When you can see the clearly defined variable of type int or string, you know exactly what kind of data you are working with.

string greeting = "Hello, world!";
int number = 5;

In contrast, Python does not provide this calibre of clarity, where data types are implicitly handled.

greeting = "Hello, world!"  # No explicit type declaration
number = 5

3) Improved refactoring and IDE support

Static typing allows your Intergrated Development Environment (IDE) to provide better support for refactoring (the process of restructuring code without changing the functionality for better readability), and auto-completion tools. Because these types are defined at compile time, IDEs can predict the methods and properties you will need, leading to accurate and accelerated code changes.

why static typing makes refactoring easier

One of the main advantages of static typing is how it simplifies refactoring. In Python, you can easily change variable names, data types, and function signatures. But the risk is that you might break something unknowingly as there is no compile-time checking.

In C#, the static typing system ensures that the compiler will let you know if you change a function’s signature and a consequent type mismatch occurs. This comes in handy when large codebases are concerned where making changes could affect multiple parts of the project.

In the end, learning C# after Python helped me understand how valuable static typing can be. It made my code more predictable, easier to understand, reduced silly mistakes, and taught me to think more carefully about how to implement a solution with robust code. While Python is great for getting started quickly and obviously many other things, learning a statically typed language taught me structure and precision. With that being said, knowing both inarguably made me a better, well-rounded programmer.