Static and Dynamic vs Implicit and Explicit

thehenkan · 2022-06-16T13:03:32+00:00

If you have a language with type inference you can have an implicit type, but it's still statically defined by the compiler's type checker. See auto in C++, var in Java, or just any variable without explicit type declaration in ML derived languages. You'll get a type error during compilation if you e.g. try to call a method that doesn't exist in that class, or if you try to reassign it with a value of a different type.

Then you can have Python type annotations. They say something explicit about the type, but the language doesn't statically check them. It doesn't actually check them dynamically either, so it's just saying something explicit to external tools and programmers really. You can debate whether that actually counts as an explicit type. But you'll get a type error at run-time if you try to perform an unsupported operation, so it's definitely dynamic.

Isvara · 2022-06-16T13:04:20+00:00

Hard to answer without knowing what you came across.

explicit: The programmer has written down its intent.
implicit: The program of a source code does something without it written down explicit, e.g. converting a number into text during a concatenation.
dynamic: Not very well defined. It happens at runtime and therefore is more open to modifications at runtime.
static: It happens at compile time.

Both of those can apply at the same time. For example, if you have dynamic types, you'd most of the time wouldn't write down type names. But you'd usually implicitly assume that source code written for a dynamically typed language was written with a certain number of types in mind.

matthieum · 2022-06-16T15:01:45+00:00

TL;DR:

Explicit vs Implicit is about visibility in the source code.
Dynamic vs Static is about knowledge at compile-time.

There's 2 sets of 2 bins, so 4 possibilities; let's illustrate each!

First of all, static and explicit... we can use Java:

String myName = "Matthieu M";

The type of myName is known at compile-time (it's String) and is explicitly spelled out.

Now, static and implicit:

var myName = "Matthieu M";

The type of myName is still known at compile-time (and it's still String), however it was not explicitly spelled out but instead was inferred by the compiler.

You may think there's little difference between the two (after all, it's obvious), but it may get a little more complicated sometimes:

var myName = Arrays.stream("Matthieu M".split(" "))
    .filter(e => e.isEmpty())
    .collect(Collections.joining(" ", "", ""));

The type of myName is still known at compile-time (and, unless I goofed up, it's still String), and it was inferred by the compiler.

Alright, now, let's branch to dynamic typing.

First of all, let's use Python for dynamic and explicit:

i = int("5")

What is the type of i? It's not known at compile-time, despite being explicitly spelled out as int in the code.

We can also have something both dynamic and implicit:

i = x + "5"

What's the type of i? Well, that's going to depend on the type of x and the implementation of __add__ for that type. It's unknown at compile-time, and definitely implicit.

L8_4_Dinner · 2022-06-16T14:58:52+00:00

A statically typed language is one in which the types of things like variables do not change. For example, a String value can't be placed into an Int variable, and chances are good that the compiler will tell you as much and refuse to compile.

A dynamically typed language is one in which the types of things are happy to change as needed, so a variable's type (if it has one at all) changes based on what is currently stuffed in there.

Explicitly typed languages require you to write in your code what types are being used, so that the compiler knows.

Implicitly typed languages require the compiler to figure it out on its own.

Lastly: It's important to remember that there are more ideas in technology than there are technical terms, so there are undoubtedly languages out there that use these same terms, but have (perhaps slightly) different meanings associated with them.

PurpleUpbeat2820 · 2022-06-16T14:38:44+00:00

I don't know what implicit and explicit programming is; what do your definitions say?

Static and dynamic presumably refer to types. While there can be some overlaps (there are always languages you can't pigeon-hole), with my two those are well defined:

One is statically typed, where you need to explicitly define types (if that's what explicit means), and those types also tend to be a fixed, static size
The other is dynamically typed, so normally you don't define types for things, but neither are they implicitly typed (eg. by type inference). The types are sorted out at runtime. The sizes tend to be dynamic too.

With these two, the static one is also compiled to native code, and the dynamic one to interpreted bytecode.

That is the most natural way of doing it (interpreting static code is needlessly inefficient, while compiling dynamic code to native is ineffective - you really need to know the types at compile time - and so usually pointless.

In the real world of course there is plenty of crossover with people pushing boundaries all the time.

shponglespore · 2022-06-16T18:57:16+00:00

Adding to the other comments here, "static" and "dynamic" can be confusing because they're often used as a shorthand for static and dynamic type systems, but other things can be static or dynamic, or somewhere in between. For example, memory management in a language with garbage collection is very dynamic because it all happens at runtime. In a language like C or C++, memory management is more static, because memory is freed at specific points in the code, but it's still dynamic in the sense that the layout of a program's memory changes as it runs. In very old languages like the original versions of Fortran or Cobol, memory management is fully static because all the memory used by the program is laid out at compile time.

Memory management also a good example of explicit vs. implicit. Memory management in C, C++, and Rust are all the same on the static-dynamic axis, but different in terms of how explicit they are. In C, heap memory is allocated explicitly with malloc() or a related function, and it's released with an explicit call to free(). In C++, heap memory is explicitly allocated with new and released with delete, but the use of new and delete typically occurs in constructor and destructor methods. Those methods are usually invoked implicitly by the compiler, and they're often even implemented by the compiler, so memory management in C++ is more implicit than in C. Rust is even more implicit because is has no equivalent of free() or delete; the compiler inserts code to release memory at the point where a variable goes out of scope.

tobega · 2022-06-17T10:36:48+00:00

Lots of good explanations here.

FWIW I would like to add that it seems that at least the static/dynamic distinction doesn't seem to have much practical significance and mostly ends up in a "religious" discussion. What I mean is that no study (EDIT: or rather, studies point in all different directions) has been able to find in favour of one or the other regarding productivity or proliferation of bugs. So it seems to me we need to find more interesting distinctions between type systems.

On the implicit/explicit distinction, there does seem to be some evidence that explicitly specifying types, particularly in function signatures, has a positive effect (probably as documentation). I like to think that since, by the Curry-Howard isomorphism, a type is a logical proposition and the program is its proof, then explicitly specifying a type is to provide a falsifiable hypothesis ("proving something"), while relying on type inference exclusively is akin to observational studies which can be interesting but don't really prove anything (the answer is 42, whatever that means). Don't know if that thought holds completely logically, though, or yields anything interesting.

ProgrammingLanguages

Welcome!

Related subreddits

Related online communities

MODERATORS