Why are semantics and type systems are so important?

Question

I heard that semantics and type systems are very important for all programmers! But I why are they so important? I don't understand. Maybe they are imortant only for theoreticians and compiler developers?

In my practice I never think about semantics and type theory. As for me it is enough to know that the semantics defines the meaning of syntax. When I write + I just know that it is the addition operation. And it is enough for me.

Then, I want to describe my thoughts about type systems. Also, when I write int i;, I know that int is an integer and it is enough for me.

Another case - it is important to know what the difference beetwen static and dynamic, weak and strong type systems.

Tell me please, are there any practical benefits from the knowledge of semantics and type systems?

Answer 1

Sublte semantic differences

Consider this simple program:

i = 1000'000'000
j = i * i

This operation can behave very differently depending on the semantics of integers in your language:

1. Some languages will seamlessly switch to big integers producing the correct result (1000'000'000'000'000'000), but degrading performance (e.g. python)
2. Some languages will seamlessly switch to floats, producing an approximate result (e.g. javascript and php)
3. Some languages will raise an error because the result doesn't fit a 32 bit integer (e.g. C# with checked arithmetic enabled)
4. Some languages will wrap around (e.g. C# with checked arithmetic disabled, returns -1486618624). The precise wrap around behaviour can differ depending on the size of the integer type and the representation of the sign (C# uses two's complement)
5. Some languages will invoke undefined behavior (e.g. C and C++)
6. Some languages will consider the literal signed, others as unsigned

Pretty big differences for something as simple as multiplying two integers.

---

Or consider the case where you write 1 + "1a".

1. Some languages will produce a compiletime error, asking you to clarify what you meant.
2. Some languages will produce a runtime error because you can't add integers and strings
3. Some languages will attempt to parse the string as number, and raise an error because "1a" is no valid decimal number
4. Some languages will successfully parse the string, e.g. because they stop parsing at the first non digit
5. Some languages will treat both as string and concatenate them.
6. C will treat "1a" as a pointer to char and perform pointer arithmetic, returning "a".

Expressiveness of the type system

Things get more interesting once you consider complex types.

Different type systems allow you to express different ideas elegantly. They catch different errors at compile or runtime. They restrict you in different ways. They require different amounts of effort to learn.

Since each programmer and language designer weights those goals differently (or isn't even familiar with the advantages of some of them) we get a lot of different languages.

• C has no convenient way to write a container that works with different types of elements. C++ has very powerful templates, but they add a lot of complexity to the language.
• Go and Java both support interfaces. In java the class needs to explicitly implement an interface, in Go a type implicitly implements all interfaces matching its members. The Go approach allows a consumer to define the interfaces that fit its requirements, but it can produce false matches when a member has the same name, but different meaning.
• Immutability simplifies reasoning about the code and enables sharing instances, but can make it inconvenient to manipulate your data.
• Static typing catches many errors at compile time. But catching more errors increases the effort required to satisfy the compiler. Depending on how you express those compile time constraints you catch different errors. We're always looking for new type systems that find more errors or require less effort.
• Rust has a type system that can prove that no two threads will unsafely modify a mutable object at the same time. But in exchange it requires meticulous ownership tracking, which many programmers will consider too inconvenient.

• There are many features a language can offer, such as objects, multiple inheritance, deterministic destruction, memory safety, a GC, discriminating unions, higher order functions, generic containers/algorithms, operator overloading.

  Each is useful in some situations, but you need to weight them against the complexity of the language and thus the effort to learn it. Some features are even incompatible or at least interact badly with each other.

Answer 2

When I write + I just know that it is the addition operation.

And how do you know that? Because the semantics of the language say so!

By the way, that isn't even universally true. For example, for Strings in Java, + is not addition, but concatenation!

when I write int i;, I know that int is an integer and it is enough for me.

And how do you know what an integer is? The type system tells you!

By the way, that also isn't universally true. For example, in Java, int is not an integer but rather a member of the modulo ring ℤ_2³²!

it is important to know what the difference beetwen static and dynamic, weak and strong type systems.

So, you say type systems are important, but then ask whether they are important?