К>+ в чём "громадные потери" и кто их мерял и как? Звучит как очередное голословное утверждение, которые уже сильно утомляют. Или потери за счёт оверхэда?

void Calculate()
{
  byte[] tmpArray = new byte[N];
  ....
  ....
  ....
}

PROCEDURE Calculate;
  VAR tmpArray: ARRAY N OF BYTE;
BEGIN
  ...
  ...
  ...
END Calculate;

void Calculate()
{
  int[] tmp = new int[100];
  ...
}

PROCEDURE Calculate;
  VAR tmp: ARRAY 100 OF INTEGER;
BEGIN
  ...
END Calculate;

namespace TestLocalArray
{
    sealed class Object
    {
        const int N = 100;
        System.Threading.Thread thread;
        int count;

//              global
//        int[] histogram = new int[N];

        public int Count {get{return this.count;}}

        int Calculate()
        {
//                      clear global array
//            System.Array.Clear(this.histogram, 0, this.histogram.Length);

//                      local array
            int[] histogram = new int[N];
            for(int i = 0; i < histogram.Length; i++)
            {
                histogram[i]++;
            }
            int result = 0;
            for(int i = 0; i < histogram.Length; i++)
            {
                result += histogram[i];
            }
            return result;
        }

        void Activity()
        {
            try
            {
                while(true)
                {
                    int x = this.Calculate();
                    this.count++;
                    System.Threading.Thread.Sleep(0);
                }
            }
            catch(System.Threading.ThreadAbortException)
            {
                return;
            }
        }

        public Object()
        {
            this.thread = new System.Threading.Thread(new System.Threading.ThreadStart(this.Activity));
        }

        public void Start()
        {
            this.thread.Start();
        }

        public void Stop()
        {
            if(this.thread != null)
         {
            this.thread.Abort(null);
            this.thread = null;
         }
        }
    }

    class Program
    {
        conts int M = 500;
        Object[] objects = new Object[M];
        void Run()
        {
            System.Console.WriteLine("Program started");
            for(int i = 0; i < this.objects.Length; i++) { this.objects[i] = new Object(); }
            System.Console.WriteLine("objects created");
            for(int i = 0; i < this.objects.Length; i++) { this.objects[i].Start(); }
            System.Console.WriteLine("threads running");
            System.Console.WriteLine("sleep 15 seconds...");
            System.Threading.Thread.Sleep(15000);
            for(int i = 0; i < this.objects.Length; i++) { this.objects[i].Stop(); }
            System.Console.WriteLine("threads stopped");
            long result = 0;
            for(int i = 0; i < this.objects.Length; i++)
            {
                result += this.objects[i].Count;
            }
            System.Console.WriteLine("result = {0}", result);
            System.Console.WriteLine("Program stopped.");
        }

        static void Main(string[] args)
        {
            Program p = new Program();
            p.Run();
            System.Console.ReadLine();
        }
    }
}

class SomeClass
{
}

PROCEDURE Calculate;
  VAR tmp: ARRAY 3 OF BYTE;
BEGIN
  ...
END Calculate;

O>Тот код, что привели вы, совершенно не показывает преимуществ обожествляемого вами Оберона, он сравнивает C# с ... правильно, с C#! Причём указывает на совершенно очевидную вещь — не выделять память каждый раз получается быстрее, чем выделять её. Кстати, в случае массива на стеке её всё равно пришлось бы выделять (на стеке), так что пример как минимум некорректен — мы так и не увидели, насколько выделение массива на стеке быстрее оного из managed heap.

O>Зато с полезностью пулов вроде как сами согласились

СГ>PROCEDURE Calculate;
СГ>  VAR tmp: ARRAY 3 OF BYTE;
СГ>BEGIN
СГ>  ...
СГ>END Calculate;
СГ>

O>>Тот код, что привели вы, совершенно не показывает преимуществ обожествляемого вами Оберона, он сравнивает C# с ... правильно, с C#! Причём указывает на совершенно очевидную вещь — не выделять память каждый раз получается быстрее, чем выделять её. Кстати, в случае массива на стеке её всё равно пришлось бы выделять (на стеке), так что пример как минимум некорректен — мы так и не увидели, насколько выделение массива на стеке быстрее оного из managed heap.

O>>Зато с полезностью пулов вроде как сами согласились

а) Либо написать компилятор моего любимого оберона под дотнет, но тогда я: 1) потеряю чисто оберонистые библиотеки исходников которых у меня нет; 2) заработаю огромадные потери производительности, так как дотнетская вычислительная модель (или как там это назвать) "слабее" чем оберонистая (в дотнете нет нормальных value-типов, массивов, вложенных процедур).

array<int>^ f()
{
    array<int> a(10); // создали массив в стеке -- в настоящее время невозможно
    . . .
    return a;         // при желании вернули, массив "забоксился"
}

int^ f()
{
    int i = 10; // создали целое в стеке
    . . .
    return i;   // вернули, оно "забоксилось"
}

struct V
{
    int x;
    int y;
    int z;
}
. . .
V v = new V();

int[] a = new int[3];

class SomeClass
{
}

PROCEDURE P;
  VAR a: ARRAY 3 OF BYTE;
BEGIN
  ...
END P;

PROCEDURE Calculate(a: ARRAY OF BYTE; IN b: ARRAY OF BYTE; VAR c: ARRAY OF BYTE; OUT d: ARRAY OF BYTE);

PROCEDURE Calculate(pa: POINTER TO ARRAY OF BYTE;
  VAR pc: POINTER TO ARRAY OF BYTE; OUT pd: POINTER TO ARRAY OF BYTE);

O>И таки очень может быть, что по итогу Оберон ещё и медленнее на аналогичных операциях?

PROCEDURE P;
  VAR a: ARRAY N OF INTEGER;
BEGIN
  ...
END P;

int[] a = new int[N];

O>>И таки очень может быть, что по итогу Оберон ещё и медленнее на аналогичных операциях?

... несостоятельность того или иного языка ...

СГ>PROCEDURE P;
СГ>  VAR a: ARRAY N OF INTEGER;
СГ>BEGIN
СГ>  ...
СГ>END P;
СГ>

СГ>int[] a = new int[N];
СГ>

ПК>array<int>^ f()
ПК>{
ПК>    array<int> a(10); // создали массив в стеке -- в настоящее время невозможно
ПК>    . . .
ПК>    return a;         // при желании вернули, массив "забоксился"
ПК>}
ПК>

ПК>int^ f()
ПК>{
ПК>    int i = 10; // создали целое в стеке
ПК>    . . .
ПК>    return i;   // вернули, оно "забоксилось"
ПК>}
ПК>

int f()
{
    int i = 10; // создали целое в стеке
    . . .
    return i;
}

ПК>struct V
ПК>{
ПК>    int x;
ПК>    int y;
ПК>    int z;
ПК>}
ПК>. . .
ПК>V v = new V();
ПК>

ПК>int[] a = new int[3];
ПК>

СГ>PROCEDURE P;
СГ>  VAR a: ARRAY 3 OF BYTE;
СГ>BEGIN
СГ>  ...
СГ>END P;
СГ>

class P
{
    private byte[] _a = new byte[3];
    public void F()
    {
        ...
    }
}

P p = new P();

for (int i = 0; i < 1000; i++)
    p.F();

PROCEDURE Clear (VAR a: ARRAY OF INTEGER);
  VAR i: INTEGER;
BEGIN FOR i := 0 TO LEN(a) - 1 DO a[i] := 0 END
END Clear

PROCEDURE Proc;
  VAR a: ARRAY 3 OF INTEGER;
    b: ARRAY N OF INTEGER;
    p: POINTER TO ARRAY OF INTEGER;
BEGIN
  Clear(a);
  Clear(b);
  NEW(p, LEN(a)+LEN(b));
  Clear(p);
  ...
END Proc;

TYPE
  A = ARRAY 8 OF BYTE;
  P = POINTER TO A;

TYPE
  R = RECORD x, y: REAL END;
  P = POINTER TO R;

-------------------
Поле чудес...
Якубович привычно спрашивает у играющей в этот раз милой блондинки:
— От чего будете страховаться?
— Ой, а можно "угадала все буквы, но не смогла прочесть слово"?

MODULE Sorter;

  PROCEDURE SortArrayOfInteger* (VAR a: ARRAY OF INTEGER);
  BEGIN
    ...
  END SortArrayOfInteger;

  PROCEDURE SortArrayOfReal* (VAR a: ARRAY OF REAL);
  BEGIN
    ...
  END SortArrayOfReal;

END Sorter.

MODULE MyModule;

  IMPORT Sorter;

  PROCEDURE MyProcedure;
    VAR a: ARRAY 80 OF INTEGER;
  BEGIN
    ...
    Sorter.SortArrayOfInteger(a); (* отсортировали *)
    ...
  END MyProcedure;

END MyModule.

struct Node // узел
{
  double x,y,z; // координаты и прочая попса
  Triangle *first; // указатель на первый треугольник вокруг узла
};

struct Triangle
{
  Node      *nodes[3]; // в треугольнике три узла
  Triangle  *next[3];  // три списка на братьев по узлу

  int node_idx(Node *)
  {
    return // номер узла в массиве nodes
  }

  Triangle* next_in_node( Node *n )
  {
    return next[node_idx(n)];
  }
};

struct Mesh
{
   NodeList     nodes;
   TriangleList triangles;
};

// точка в N-мерном пространстве
template <int N, class T>
    struct Point;

// точка в 2-мерном пространстве
template <class T>
    struct Point<2,T>
{
    T    x, y;
// операторы + - и т.д. поскипаны для краткости
};

// точка в 3-мерном пространстве
template <class T>
    struct Point<3,T>
{
    T    x, y, z;
};

// Теперь имея классы Point<2,T>, Point<3,T> и Point<сколько_надо,T>
// наслаждаемся всю оставшуюся жизнь:

// вычисление точки на отрезке в N-мерном пр-ве
template <int N, class T>
    Point<N,T> line_point( const Point<N,T> &A, const Point<N,T> &B, T u )
{
    return A + (B-A)*u;
}

// И таким макаром без лишней суеты и напряга
// имеем все остальные алгоритмы и классы
// например сплайн на плоскости и в пространстве
template <int N, class T>
    struct NurbsCurve
{
    typedef Point<N,T>    PointNT;

    int                n;
    int                p;
    vector<T>               U; // кнот-вектор
    vector<PointNT>         P; // опорные точки
    vector<T>               W; // веса

    PointNT point( T u ); // понеслась
};

typedef NurbsCurve<2,double> NurbsCurve2d; // сплайн на плоскости
typedef NurbsCurve<3,double> NurbsCurve3d; // сплайн в пространстве

void test( Point<2,float> a, Point<3,double> &b )
{
  b.z = max(a.x, a.y);
}

struct Point
{
   public double[] coords;
   public Point( int N )
   {
      coords = new double[N]; // Позор и отстой
   }

}

// точка в 2-мерном пространстве
template <class T>
    struct Point<2,T>
{
    T    x, y;
// операторы + - и т.д. поскипаны для краткости
};

// точка в 3-мерном пространстве
template <class T>
    struct Point<3,T>
{
    T    x, y, z;
// операторы + - и т.д. поскипаны для краткости
};

СГ>// точка в 2-мерном пространстве
СГ>template <class T>
СГ>    struct Point<2,T>
СГ>{
СГ>    T    x, y;
СГ>// операторы + - и т.д. поскипаны для краткости
СГ>};

СГ>// точка в 3-мерном пространстве
СГ>template <class T>
СГ>    struct Point<3,T>
СГ>{
СГ>    T    x, y, z;
СГ>// операторы + - и т.д. поскипаны для краткости
СГ>};
СГ>

Point<N,T> NurbsCurve<N,T>::point( T u ) const
{
    HPoint<N,T> cw;
    int p    = m_U.p();
    int i    = m_U.knot_span(u);

    T N[Geom::nurbs_p_max + 1];

    m_U.calc_basis_funs( N, u, i );
    for ( int j = 0; j <= p; j++ )
        cw += m_Pw[i - p + j] * N[j];
    return cw.euclid();
}

signature Point =
  sig
    type t
    type p
    val + : p* p -> p 
    val - : p* p -> p 
    val * : t* p -> p 
  end;

functor PointOps(Pt:Point) =
  struct
    open Pt;
    fun line_point (a:p,b:p,u:t) = a + u * (b-a);
    type  NurbsCurve = {U:t list, P:p list, W:t list}
  end;

structure Point2D:Point  = 
  struct
    type t = real
    type p = {x:t,y:t}
    val op + = fn ({x=x1,y=y1},{x=x2,y=y2})=> {x=x1+x2,y=y1+y2};
    ...
  end;

structure PointOps2D = PointOps(Point2D);
type NurbsCurve2d = PointOps2D.NurbsCurve;