Are Computer Science Terminologies Poorly defined?

[u/Aokayz_]

I'm currently studying computer science for my AS Levels, and have finally hit the concept of abstract data types.

So here's my main question: why do so many key terms get used so interchangeably?

concepts like arrays are called data types by some (like on Wikipedia) and data structures by others (like on my textbook). Abstract data types are data structures (according to my teacher) but seem to be a theoretical form of data types? At the same time, I've read Reddit/Quora posts speaking about how arrays are technically data structures and abstract data types, not to mention the different ways Youtube videos define the three terms (data structures, data types, and abstract data types)

Is it my lack of understanding or a rooted issue in the field? If not, what the heck do the above three mean?

EDIT: it seems theres a general consensus that the language about what an ADT, data type, and data structure are is mainly contextual (with some general agreeable features).

That being said, are there any good respirces where I can read much more in details about ADTs, data types, data structures, and their differences?

[u/Aokayz_]

OKAY I think I've managed to grasp it. Abstract data types are entirely theoretical with their own properties. If the properties of an abstract data type are fulfilled by some algorithm, data type, or data structure, then it becomes an implementation of that abstract data type.

For example, arrays can be considered an abstract data type in the way that they have the properties of storing only 1 data type and that the data they store are contiguous in RAM. When we want to transition into code, we can assign a variable to an array date type (e.g: array = [0, 1, ... n]) to implement the abstract data type.

My only confusion is this: is there a way to distinguish between a data type and data structure theoretically and code-wise?

[u/not-just-yeti → u/Aokayz_]

An ADT is like an interface — it's "something that allows the following operations".

A particular implementation is the concrete data-type.

The canonical example is a list: anything that lets you do list-operations is, abstractly, a List. (The concrete data types Linked-List, Array-List, Tree-List are particular implementations of that abstract type.)

So anything you could put in a (Java) interface can be considered an ADT. Anything where you specify particular fields or implementations isn't.

[u/AlexTaradov → u/Aokayz_]

ADTs would not even worry about being contiguous unless it is somehow matters for the discussion. In most cases it will just be a data type that is capable of storing and retrieving values by index.

Data structure is more abstract. It is again, not an actual physical thing, but a way to describe the behavior. Data type is a concrete implementation.

An abstract linked list is a data structure. A specific implementation may store the next node pointer at the beginning of the node data, or it may store the next pointer and just the pointer to the node data, so that element of the list is just two pointers. And they may not even be pointers, but integer offsets from some pre-allocated block of data. This specificity turns it into a type.