Quote:Original post by Xeee
using a couple of assert's and good programming practices, most of the problems he talked about will be gone.

class dynamic_array{    int *arr_;    size_t size_;public:    void set_new_size(size_t size)    {        size_ = size;        if( arr_ )            delete arr_;        arr_ = new size;    }    int operator[](size_t index)    {        assert( index > 0); // Do you always make this check? I avoid it sometimes, but it could introduce errors        assert( index < size_);            return arr_[index];    }};

arr.set_size(5);arr[4]; // Just access it, we don't need to run it

arr.set_size(3);

Quote:Original post by CoffeeMug
How does he propose to statically verify this:

int n = random();arran[n];

Quote:Original post by CoffeeMug
Link.

Some of his statements lead me to believe he has no idea what he is talking about. For example, he suggests that array bounds access should be entirely verified at compile time.

Vertex[] Transform (Vertex[] Vertices, int[] Indices, Matrix m){  Vertex[] Result = new Vertex[Indices.length];  if (!Vertices || !Indices)    return null;  if (!m)    m = new Matrix;  for (int i = 0; i < Indices.length; ++i)    if (Indices < 0 || Indices > Vertices.length)      Result = new Vertex;    else      Result = Transform(m, Vertices[Indices]);  return Result;}

Transform{n:nat} (Vertices: [n]Vertex, Indices: []nat<n, m: Matrix):[]Vertex=  for each (i in Indices)    Transform(m, Vertices)

Transform{n:nat} (Vertices: [n]Vertex, Indices: []nat<n, m: Matrix):[]Vertex=  for each (i in Indices)    Transform(m, Vertices)<br></pre><br><br>Here the compiler will be able to determine that "i + 1" <i>could be</i> greater than &#111;ne minus the length of the Vertices array, and issue a warning or, depending upon how paranoid you've told the compiler to be, an error.<br><br><!–QUOTE–><BLOCKQUOTE><span class="smallfont">Quote:</span><table border=0 cellpadding=4 cellspacing=0 width="95%"><tr><td class=quote><!–/QUOTE–><!–STARTQUOTE–><br>How does he propose to statically verify this:<br><pre><br>int n = random();<br>arran[n];<br></pre><br><!–QUOTE–></td></tr></table></BLOCKQUOTE><!–/QUOTE–><!–ENDQUOTE–><br>Okay. I'll bite. The example is, apparently unknown to you, a particularly good &#111;ne for Tim's case because it might well break at run-time, so it may be useful to be warned about this fact. We'll say it's an error if we can't be sure that the access is valid at compile-time.<br><br><pre><br>int n = random();<br>array[n]; // Error: Possible out of bounds array access.<br></pre><br><br>The first thing is to ensure that the code can't ever break at runtime. This is achieved by ensuring that the index is always less than the length of the array.<br><br><pre><br>int n = random() % array.length;<br>array[n]; // Error: Possible out of bounds array access.<br></pre><br><br>I've assumed that the compiler 'forgets' that n must be in the range [0, array.length) when it is assigned to an 'int' variable. We need to give a more precise type:<br><br><pre><br>int&lt;0, array.length&gt; n = random() % array.length;<br>array[n]; // Okay.<br></pre><br><br>Note that it doesn't matter that we don't know the length of the array yet. What's important is that there's a contract which says that it's always okay to access an array element if the index can be proven to be between 0 and &#111;ne minus the length of the array, which n's type guarantees.

Quote:Original post by xiuhcoatl
Complete modeling ends up being a much harder problem to solve and really doesn't provide additional benefit.

Quote:Original post by ApochPiQ
Unbounded array access should be easy to catch, sure. But in my view, this should be causing a build failure, too:

int milliseconds = timeGetTime();int playerhealth = milliseconds;

I'd love to be able to write code like this, and have it enforced at compile time:

DataType milliseconds Basis:Integers Storage:WhoCaresDataType hitpoints Basis:Naturals Storage:WhoCaresDataType flatpercentage Basis:Naturals Storage:WhoCares Validation:{x < 100}DataType somebitmask Basis:BitField Storage:Bits32

unit metre;unit centimetre = metre / 100;unit inch = centimeter * 2.54;

float acceleration a = Physics.G * planet.mass /                       length(object.location - planet.location);