3 ms·
Funny how things change. Two of the deficiencies: - the absence of global state - array dimensions part of the type may have been considered defects back
by toolslive 12y ago
Funny how things change. Two of the deficiencies:
- the absence of global state
- array dimensions part of the type
may have been considered defects back then,
but are currently seen as a good thing.
[For example, in Haskell, they consider it fancy that you can add dimensions to your type signature so the compiler can check if you're not doing something silly.]
Also, I programmed extensively in Pascal using the Borland IDE in the early 90s and it was one of the best IDEs I ever encountered.
As troll bait, let me just throw in this: the compiler had better inline assembly than what gcc provides 20 years down the road.
- habitue 12y agoC also has arrays with dimensions as part of the type. The trick is that the dimension must be determined statically. This is different than vectors in Haskell which allow the size of the vector to be determined (and even vary) dynamically, yet still guarantee memory safety statically (I.e. no runtime cost for bounds checking). You can think of an array with a static size of 10 as being like shorthand notation for a struct with ten fields (sans padding). It really is no more complicated than that.
- pjmlp 12y agoTry to use those arrays as function arguments.
- habitue 12y agoI believe that works fine (at least in C). You have to statically put the array size into the function signature, so it will only work on arrays of that size. I was simply pointing out the difference between dependently typed vectors which have the type checker prove you use the vector correctly, and arrays in c and pascal whose sizes are known at compile time. I am agreeing with the author that this makes it hard to create generic array bounds if you don't have the ability to make unbounded arrays (as c does). I was disagreeing with the gp, who was conflating these two different sorts of types.
- pjmlp 12y agoSo I guess you aren't confortable with the C standard. Functions don't take arrays size statically in arguments. Whatever you write is ignored.
- ufo 12y agoIIRC, if you have multidimensional arrays only the last dimension is ignored so arr[3][4] is equivalent to arr[3][]. Of course, in the one dimensional case it means that the dimension is ignored.
- habitue 12y agoIt's been a few years since I've written a lot of C. ufo's sibling comment reminded me of how it acts (the last dimension is ignored). Anyway, this is completely beside the point of what I was talking about. The point is that a static size is a very different level of type system machinery from a dynamic size.
- pjmlp 12y agoMy point is that although they are static allocated, the moment you pass them as arguments, they are just another pointer. Which leads to those beautifull security exploits.
- sparkie 12y agoC++ has also realized that array dimensions as part of the type are the right way forward. It's encouraged that you use std::array and avoid plain old arrays (which can't work in combination with smart pointers, for example).
- Havoc 12y ago> the compiler had better inline assembly than what gcc provides 20 years down the road. Also...stupidly fast build-times. First time I compiled something on VS I thought the thing had frozen. Nope...just slow.
- hyperpape 12y agoWell, it's not just array dimensions as part of the type, it's array dimensions as part of the type and _no generic functions over them_.