MODULE TestTest;
IMPORT StdLog, Integers; 

PROCEDURE Test1*;
VAR n: Integers.Integer; s: POINTER TO ARRAY OF CHAR; 
BEGIN 
  n := Integers.Power( Integers.Long(123456789), 23); (* n = 123456789 ^ 23 *) 
  NEW(s, Integers.Digits10Of(n) + 1); Integers.ConvertToString(n, s); 
  StdLog.String("123456789 в степени 23 = " + s);
END Test1;

END TestTest.

123456789 в степени 23 = 1273047108741566448925177913751616696945898387964743103636779445049184442828420773403202324032930504017546460440185735271601405046465292219398244646351144254623692836888914694403194587869

class Class1
{
    Class1 next;
    int i1 = 1;//Заведем несколько переменных(чтобы память быстрее заканчивалась)
    int i2 = 1;
    int i3 = 1;
    int i4 = 1;
    int i5 = 1;
    int i6 = 1;
    int i7 = 1;
    int i8 = 1;
    int i9 = 1;
    int i0 = 1;
    static void Main(string[] args)
    {
        Class1 c = null;
        int i = 0;
        while(true)
        {
            Class1 n = new Class1();
            n.next = c;
            c = n;
            ++i;
            if(i%1000 == 0)//Консоль штука тормозная :(
                Console.WriteLine(i);
        }
    }
}

WH>Этот код конечно не роняет .НЕТ но программа примерно на 9 миллионах итераций уходит в глубокий ГЦ... но из него всеравно не вернется...

WH>class Class1
WH>{
WH>    Class1 next;
WH>    int i1 = 1;//Заведем несколько переменных(чтобы память быстрее заканчивалась)
WH>    int i2 = 1;
WH>    int i3 = 1;
WH>    int i4 = 1;
WH>    int i5 = 1;
WH>    int i6 = 1;
WH>    int i7 = 1;
WH>    int i8 = 1;
WH>    int i9 = 1;
WH>    int i0 = 1;
WH>    static void Main(string[] args)
WH>    {
WH>        Class1 c = null;
WH>        int i = 0;
WH>        while(true)
WH>        {
WH>            Class1 n = new Class1();
WH>            n.next = c;
WH>            c = n;
WH>            ++i;
WH>            if(i%1000 == 0)//Консоль штука тормозная :(
WH>                Console.WriteLine(i);
WH>        }
WH>    }
WH>}
WH>

  Class1 n = new Class1(); (* Создаем новый элемент списка   *)
  n.next = c; c = n;       (* Записываем этот элемент в список первым *)

void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    // сначала запишем длинну, заюзав хелпер
    IBinStream_int_put( stm, pts_size );
    // опаньки, для типа Point никто хелпер не написал, юзаем вирт. метод через класс
    stm.write( pts, sizeof(Point) * pts_size );
}

// что же получилось? код в котором нет никакого однообразия.
// хотя операции одни и те же: запись в поток
// плохо читается да и писать такое не очень приятно

// можно переписать так:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    IBinStream_int_put( stm, pts_size );
    for ( int i = 0; i < pts_size; i++ ) {
        IBinStream_real_put( stm, pts[i].x );
        IBinStream_real_put( stm, pts[i].y );
        IBinStream_real_put( stm, pts[i].z );
    }
}

// более однообразно, но производительность будет ниже унитаза

// получается что в итоге надо либо полностью отказатся от хелперов:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    stm.write( &pts_size, sizeof(uint) ); // юзаем вирт. методы
    stm.write( pts, sizeof(Point) * pts_size );
}

// тем самым лишив себя всякого удобства,
// и постоянно контролируя себя правильный ли sizeof передан

// либо юзать только хелперы:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    IBinStream_int_put( stm, pts_size ); // хелпер для "удобства"
    IBinStream_write( pts, sizeof(Point) * pts_size ); // хелпер обертка
}

// а теперь посмотрите на этот вариант и сравните его со всеми остальными:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    stm.put( pts_size );
    stm.put( pts, pts_size );
}

// и что же мы видим? видим, что на сложном плюс-плюсе можно действительно писать простой код
// а на простом обероне код получается примитивным и плохочитаемым.
// плюсовое решение и красивое и однообразное и быстрое и легкочитаемое
// а в обероне либо однообразно, но не быстро. Или однообразно, но не удобно и т.п.

Модульная расширяемая система от того и называется расширяемой, что добавление в нее нового модуля не может привести к поломке в уже установленных модулях. Добавление нового модуля не обязывает проводить полный integrity check. Если каждое добавление нового модуля обязывало бы проводить полную проверку целостности, то такая система не могла бы называться РАСШИРЯЕМОЙ просто по определению расширяемых систем.

Написание программы с помощью ИИ заключается в подаче команды "написать программу".
Отладка заключается в подаче команды "написать программу без багов"