Hacker News Reader

Comment by dleslie | Hacker News Reader

I was interested and intrigued, but then:

     // A dynamically sized array, like `std::vector`.
     var circles: Array(Circle) = ({.r = 1.0}, {.r = 2.0});

Yegads, they've put effort into ensuring API and ABI compatibility with C++, but they've gone and decided to change the meaning of nouns for basic types?!

Why, just why would introducing that obvious footgun be appealing? It raises the concern that the language is full of other arbitrary choices hiding dangerous footguns.

Edit:

Strangely, their test suite makes it look like Array is bounds checked and fixed size; there is no test for resizing:

https://github.com/carbon-language/carbon-lang/tree/trunk/ex...

View on HN

It's std::vector that was weirdly named. In plenty of codebases "Vector", particularly gamedev and scientific, will mean the mathematical object with that name.

Other languages don't need to replicate this mistake.

And yet it is the name used in C++ code for a variable length container of contiguously stored data.

This is intended to be a different language, is it not?

Not wholly different; it appears to be intended to interop with, and progressively replace C++ in existing projects.

True, though in OP's defense I don't know if I've ever seen a language refer to a growing list of entries as an "array".

Well, the data structure is called a dynamic array

I don't see any reference to it in the GH readme, but I do wonder what they call actual arrays (as in, fixed size allocations of memory that store a contiguously typed value).

I was talking about std::vector (and Rust's Vec). Those are dynamic arrays (as in, growable allocations of memory that store a contiguously typed value).

Java: ArrayList

Zig: ArrayList

GLib: GArray

Objective-C: NSMutableArray

FWIW, ArrayList is a List, backed by Arrays.

So List would have been the more Java/Zig way to name it (also Python, etc.)

> FWIW, ArrayList is a List, backed by Arrays.

You probably know that, but just to clarify: it's backed by a single array, reallocated repeatedly, just like std::vector in C++ (although growth factors are different, I think).

Just "List" probably risks that some people will jump to the conclusion that it's a linked list. I'd probably prefer the full "ArrayList". Although personally I'd use something like "DynArray"/"DynamicArray".

These are examples in favor of my point, not against it.

Doesn't seem particularly uncommon. Perl, JavaScript, and Ruby come to mind if you're really looking for languages that use just a raw term "array" with no extra qualifiers.

Object Pascal's arrays are dynamic.

var kek: array of int;

setlength(kek, 666); // kek is now int[666]

setlength(kek, 1337); // kek is now int[1337]

Java's Vector looks around awkwardly, hoping everyone forgets it existed... ;)

Actually, I've never known it existed. You're the one who reminded me now. :)

With the new versions of the JDK I think they will.

The Java Vector features will be out of incubator in the next year or so and unlike the existing Vector, it's actually useful. For context the new vector features are for SIMD support on the JVM.

I'm honestly surprised java.util.Vector still exists. It was "deprecated" in 1.2 or something like that? I guess there's no pressure to actually remove it, though.

I only know about it from dealing with J2ME crap where ArrayList wasn't available.

Java doesn't remove things from the standard library. AWT is still around, too.

An std::vector is a vector in the mathematical sense, though. It's a homogeneous tuple. It's just that using an std::vector of std::vectors to store a list of points would be inefficient.

A vector can't change its size or contain things that aren't elements of a field. A std::vector can.

Yes, you can have a vector of, say, naturals. I'm pretty sure you can even create a vector field out of vectors of non-reals.

A "vector field" and a "field" are two completely different notions. (And yes, you can build a field from integers.)

https://en.wikipedia.org/wiki/Finite_field

My bad. I meant to say "vector space", not "vector field". I understand the difference, but I often make this mistake because the set of a vector space is almost always the set of an algebraic field (i.e. the reals).

Really? What is the additive inverse of (1, 2, 3) ∈ ℕ³ ?

It depends on how you define addition.

I guess you could make it a vector space through a bijection with the rational numbers, but something tells me C++ programmers don't have that in mind when writing std::vector<unsigned>. And it doesn't solve the problem that C++ “vectors” are resizable.

See my comment above on the subject.

(-1, -2, -3), is it not?

That's not a vector of natural numbers.

Ah, missed the N... But more interestingly, the non-negative integers 0...p-1 modulo a prime number p form a field (where -1, -2 etc. appear in a natural way), and so their tuples of some fixed length do form a vector space.

It's not. Vectors can be added together and multiplied by scalars. That they are often represented as tuples of coefficients is just notation, doesn't matter for the notion of vectors, and vice versa: a tuple is not necessarily a vector.

1. std::vector doesn't have a fixed dimensionality, as would a mathematical vector. A fixed-length array actually makes more sense as a vector.

2. It doesn't provide the operations of addition and multiplication by scalars out-of-the-box (though you can whip up your own). Moreover, in general those operations wouldn't make sense for the elements which can be stored in a std::vector. E.g. neither multiplying bank account numbers by scalars, nor adding two bank account numbers make any sense. It would be good if you modelled them with types which don't allow those operations. Yet storing them in a std::vector makes perfect sense. But std::vector (or tuple) of bank account numbers is not a vector.

Worse, they have been calling the location of a pointer to a subroutine that handles an interrupt a "vector" - the word which was originally used to refer to the entire set of such locations. (Curiously, this usage is similar to how the word "sector" is used to refer to a physical record on a disk - simply because it usually comes last in the coordinate triple (cylinder, track, sector). This would be like calling a point in the 3-dimensional space a "Z".)

1. That doesn't make it not-a-vector. It just means there isn't a one-to-one correspondence between std::vector<T> and T^n. However, a particular instance x of std::vector<T> is still a T^x.size().

2. Operations are not intrinsic to a set, but to an algebra. Why would there need to be any correspondence between the operations of linear algebra and those of banking algebra in order to call an std::vector a vector?

2. I'm not sure I understand you here. A vector is defined by those operations. A set without those operations, even if it has the same elements, is not a set of vectors anymore. I don't understand your remark about sets here. The correspondence is necessary, because those operations on vectors are induced from the operations of the relevant field of scalars. The operation of adding vectors of bank numbers would be induced from the operation of adding bank numbers, if there was any such thing. The operation of multiplying vectors by scalars (bank numbers in this case) would need to be induced from the operation of multiplication of bank numbers, if there was any such thing. Anyway, I think you got hung up on the example, when the point is you can have std::vectors of types for which those operations don't make any sense. Now, imagining that perhaps there hypothetically might exist some definitions of those operations, just to convince oneself that std::vector is a vector is really stretching it, and I'm not even sure at this point if you're not trolling.

Anyway, as another commenter pointed out, Stepanov himself, who gave this container its name, said that it has nothing to do with vectors, and he wouldn't name it vector, if he could correct this mistake.

A vector is defined as I did above. It's a homogeneous tuple, i.e. the Cartesian product of n sets, where all sets are the same. Vector addition plus scalar multiplication are not part of the set. Usually they're part of the definition of a vector space. E.g. (R^2, +, ⋅). But you can construct a vector space out of a set of non-vectors (such as matrices), or out of operations other than vector addition and scalar multiplication, and you can use vectors for purposes other than constructing vector spaces, also without involving either of those operations. For example, to store sequential information.

Then you're using a definition of vector, not used in any mathematics course.

> you can construct a vector space out of a set of non-vectors (such as matrices)

A vector is by definition no more and no less than an element of a vector space. Vectors are defined by vector spaces, not the other way around.

If you have a vector space whose elements are matrices, then those matrices are vectors. And they will be written in coefficients in a given base as tuples.

> out of operations other than vector addition and scalar multiplication

You don't "build vectors out of operations like vector addition and scalar multiplication", as in: you don't choose them. You choose the field and dimension, and those operations (vector addition and scalar multiplication) are a consequence.

> you can use vectors for purposes other than constructing vector spaces, also without involving either of those operations

Again, you don't construct vector spaces out of vectors - there are no vectors without vector spaces. And there are no vector spaces without those operations. But yes, you can use vectors from a given vector space in a greater capacity than just as vectors.

An example, which shows the futility of looking at vectors as just tuples: a real number is a vector in the vector space of real numbers over the field of rational numbers.

>Then you're using a definition of vector, not used in any mathematics course. [...] A vector is by definition no more and no less than an element of a vector space.

It's the definition I was given. If you accept that the word "vector" may be given a definition different from the one you give it, you'll need to concede that an std::vector may be a vector.

>you don't choose them. You choose the field and dimension, and those operations (vector addition and scalar multiplication) are a consequence.

You're using the phrase "vector addition and scalar multiplication" in a different sense than I meant. I was referring to component-wise addition between two vectors and to multiplication between a scalar and the individual components of a vector. You could choose different operations to construct a vector space, as long as they meet the requirements of vector spaces.

You used the phrase to refer to the constructing operations of a vector space. So yes, a vector space is indeed constructed out of the operations it is constructed out of. You could have been more charitable in your interpretation of my words, rather than assume I was saying something equivalent to "four-cornered triangle".

A vector is definitely not defined as you did above.

A vector is an element of a vector space, basically anything that you can add together and multiply with an element of a field. It has nothing to do with what you wrote above.

[] : https://en.wikipedia.org/wiki/Vector_(mathematics_and_physic...

Ironically, C++ does have a standard container that can be added together and multiplied by scalars... and it's called an array; std::valarray, to be specific.

No it's not and even Stepanov, the person who gave it its name, has admitted it was a mistake:

Link to lecture by Stepanov: https://www.youtube.com/watch?v=etZgaSjzqlU

Furthermore in his book "From Mathematics to Generic Programming", Stepanov says that if he could change its name, he'd have named it "array".

Indeed, "vector" appears to be relatively recent terminology, it has been "array" since the dawn of programming. But it's too late now, and we already have the std::array anyway...

>An std::vector is a vector in the mathematical sense

No, because you can't prove that std::vector<T> obeys all vector space axioms[1] for all T, which is good because it's impossible, I can trivially define a T that will break any number of axioms and the cpp compiler will happily let me instantiate std::vector on it.

[1] https://www.math.ucla.edu/~tao/resource/general/121.1.00s/ve...

Why is it an obvious footgun?

A developer familiar with C++ may believe it to be a fixed length container (perhaps with automatic bounds checking[0]) and treat it as such in memory/security/performance critical sections.

0: https://en.cppreference.com/w/cpp/container/array/at

And if they named it “vector”, a developer familiar with mathematics might believe it to be a vector.

Which is not a footgun.

It actually can be, mathematical vectors gaurantee for example that x+y == y+x for all x,y, but no such gaurantee can be ever made on the user-defined operator+, indeed you can't even gaurantee that it is defined to begin with, let alone in the manner prescribed by linear algebra.

The language is designed to replace, by progression, C++ for C++ developers.

Mathematicians are probably better suited to using R, Julia, Octave, or Wolfram.

Reply on news.ycombinator.com