Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>А они, как правило, аргументируют примерно так:

Геннадий мое почтение, получил масс удовольствия

Только ты не дописал...

Действующие лица:

Евангелист, он же коммивояжер, исполнитель скажем Дон Коробочка.
Глашатай, ну сами знаете кто.
Он, Геннадий например.
Угрюмый, простой инженер, он же девелопер.

Действо №1:

Угрюмый: ...так это я написал... как бы его назвать? Пусть будет CORBA...
Евангелист (шепотом, смотря из-за плеча) "ух ты!"


Ария Евангелиста:
(место действия VSLive New York 2001):
Так, пацаны, бросайте все, вот вам .COM.
Вот смотирте жмем кнопку тут и все — оно само жужжит.
И самое главное! У нас уже все на нем пишут!

Глашатай (восторженно): Ура! (уходит окрыленный в массы...)

... тут идет рекурсивный вызов диалога который приведен внизу

Занавес.

Действо №2:

Угрюмый: ...так это я написал... как бы его назвать? Пусть будет Java Virtual Machine...
Евангелист (шепотом, смотря из-за плеча) "ух ты!"
.....

Ария Евангелиста (место действия VSLive SanFrancisco 2005):
Так, пацаны, бросайте .COM, с ним все оказолсь плохо.
Промашка вышла. Поэтому все переходим на .NET!
У нас уже все на нем написано, вот смотрите —
теперь даже кнопку жать не надо — оно само жужжит
а мусор который оно при этом делает сам шурша убирается. Клево, да?

Глашатай (восторженно): Гип-гип-ура! (уходит окрыленный в массы...)

...

Глашатай .Net: Мир поменялся! Всем переходить на .Net!
он: И я?!
Глашатай .Net: Да!
он: А почему?
Глашатай .Net: Так надо! У тебя проблемы с утечками памяти и <много всего>!
он: У мна? (ошарашенно оглядывается по сторонам) У мна их нет. Уж лет пять как.
Глашатай .Net: У меня есть проблемы! У моих коллег есть проблемы с галимым C++! Потому — все на .Net!
он: Хм... (скребя лысину) ну у всех есть проблемы конечно, а какие из них вы можете решить?
Глашатай .Net: ВСЕ!
он: (показывая пальцем в распечатку, с надеждой) а вот эту?
Глашатай .Net: ЛЕГКО! (отрывает кусок распечатки и выбрасывает) Это теперь МУСОР, пацан, забудь!
он: Постойте но как же он... того...
Глашатай .Net: От пристал... у нея там думатель унутре. Понял?! И вообще речь не о том!
Главное что порог вхождения низкий...
он: Хм... а я уже здесь как бы. Мне выйти и зайти?
Глашатай .Net: От ты, пацан, нудный... Ты, пацан, лучше уйди ваапще.
Я в трех фирмах секретных работал... Бааальших-пре-больших,
в три раза бОльших индийских бодишопов и нигде таких нудных не видел...

(Тут продуктивня беседа прерывается криком)
Крик Евангелиста: Девлоперс, девлоперс, девлоперс!
Глашатай .Net: Слышу, слышу... (переходит в следующую комнату)
Угрюмый: (напевает под нос) девлоперс, девелоперс, да мы девелоперс...
так это я написал... как бы его назвать? Ну скажем Web2...

Евангелист (шепотом, смотря из-за плеча) "ух ты!"

....

Ария Евангелиста (место действия недалекое будущее):
Так, пацаны, писали мы писали ту Висту.... корче так, все на .WEB !

---------
Мужики, без личных обид пожалуйста.

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>Не хотите — не доказывайте, Ваше право. Но и не ждите серьёзного отношения к бездоказательным (сиречь — голосоловным) утверждениям.

Твои утверждения не менее голословны.

Что касается позиций, то я лично наблюдаю другую картину.

Фанат плюсов:

- Вот все говорят о дотнете, а ведь это полная туфта. На нем же даже игрушку написать нельзя.
— Помилуйте, вот игршка. Загрузите, поглядите.
— Но на нем же даже софт-риалтайм системы невозможно создать. Причем принципияльно!
— А вы их создаете?
— Я, нет. Но все же.
— Кстати, вот сообщение о выпуске конторой ХХХ софтреалтайм-рантайма для Явы, а вот описание разработки того же самого для дотнета.
— Да? Наверно это фигня. Да и ведь не хард! Ну, тогда ЖЦ торомзит. Пример — Янус. У меня при считавании сообщений иногда тормоза. И при переключении веток тоже.
— По милйте, откройте любой профайлер и вы увидите, что ЖЦ не оказывает никакого влияния на скорость наботы Януса. Например, у меня время проведенное в ЖЦ составляет 0.02%. При открытии сообщения, Янус лезет в БД через JET, считывает строку и передает ее в IE-контрол. И JET, и IE — это анменеджед-контролы написанные на С++. Так что тормоза Януса являются чисто алгоритмическими и уж скорее могут быть ассоциированы с С++.
— А...А...А, тогда дотнет жрет очень много памяти!
— Насколько много?
— Вот янус жрет 60 метров.
— А сколько у вас ее всего?
— Гиг.
— И это вам мешает?
— Мне нет, но все же. К тому, же дотнет интерпретатор, вот поглядите как в янусе переключаются сообщения.
— Помилуйте, дотнет джитер.
— Да какая разница?
— Дык, он порождает компилированный код который мало чем отличается от порождаемого средним С++-компилятором.
— А...а...а, вот еще у дотнета есть куча рантайм-проверок.
— Да есть, но она делаются не всегда и часто оптимизируются. В итоге сумма оверхэда и отсотвания оптимизатора редко позволяет С++-коду обогнать управляемый больше чем на 20%. Плюс к тому же всегда есть возможность при крайней необходимости воспользоваться небезопасным кодом и породить такой же кода как на С++/С.
— А какой же тогда смысл в C#?
— Дык, оптимизировать нужно очень малый объем кода. А остальной при этом пишется проще и быстрее.
— Нифига не проще!
— Да, как же не проще? Я вот писал на С++ и после перехода на дотнет и C# по пошествию некоторого времени начал работать намного продуктивнее.
— А мой опыт показывает, что нифига на C# писать не быстрее.
— А вы пробовали.
— Да! Я попробовал писать на C# "Дарова, мир!", поплювался на непривычных синтаксис и бросил.

Короче, этот рассказ можно продолжать еще долго.

Здравствуйте, VladD2, Вы писали:


VD>Видимо у него не получилось.

Вот дела, и у меня теперь не получилось до Влада мысль довести. Уважаемый, дело не в окружающих...

ПК>> Соответственно, само по себе наличие исследований ни о чем, кроме интереса к теме, не говорит.

VD>Ошибашся. Оно говорит, о том что есть некие задачи и некие идеи которые проверяются/решаются. Собсвенно идея Сингулярити довопльно проста — это создание безопасной и предсказуемой ОС. Как я понимаю, проект на том этапе когда можно говорить, что иди проверяемые в проекте подтвердились. Конечно до промышленной/коммерческой ОС еще далего, но говорить о Сингулярити как о каких-то там непроверенных задмуках мякго говоря не честно.

Влад, идей проверяется на миллион, причем в последствии оказывается полезными единицы. Таков мир. Опять же, ты домысливаешь "Как я понимаю, проект на том этапе когда можно говорить, что иди проверяемые в проекте подтвердились". А что ты в этом понимаешь? Ты участвовал в разработке какой-то OS? Я, к примеру, ничего не понимаю и не решаюсь судить. Хотя, подобных околовсяческих спецов я уже видал.

Здравствуйте, eao197, Вы писали:


VD>>За такой код в промышленных системах нужно по началу лишать премий, а потом выгонять если не прочувствушь. Это называется начхание на инкапсуляцию.

E>А можно ли раскрыть эту тему по подробнее? Что именно плохо в приведенном коде (особенно с поправкой на то, что это врядли в точности тот код, который используется в реальной системе, а больше похож на быструю "выжимку" из оного)?

Не обращай внимания. Он по своей дурацкой привычке оппонента зачморить пытается.

Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, mrozov, Вы писали:

M>>По-моему — это факт.

AVK>Спорить о вкусе устриц, как это не печально, можно только с теми, кто их ел.

Если честно то я например устриц не ем.
Мне почему-то достаточно их запаха.

Это я так просто...

Здравствуйте, DarkGray, Вы писали:

E>>А еще более вероятно, что в реальной системе что-то вроде:

DG>И это все шаманство будет быстрее, чем:
DG>return nodes[(idx+2)%3];

Думаю, что вполне возможно. Т.к. assert во время отладки удаляет все обращения по неверному индексу. В релизе, с большой вероятностью, все вызовы инлайнятся, а assert изымается, поэтому лишнего оверхеда нет. А в твоем варианте взятие остатка от деления будет всегда.

Здравствуйте, eao197, Вы писали:

E>Думаю, что вполне возможно. Т.к. assert во время отладки удаляет все обращения по неверному индексу. В релизе, с большой вероятностью, все вызовы инлайнятся, а assert изымается, поэтому лишнего оверхеда нет.
Вот тут не понял. Куда изымется второе косвенное обращение? Мы же должны сначала обратиться по адресу imap+idx+2, и прибавить полученное смещение к nodes. При этом nodes лежат очень далеко от imap, потому что они в хипе, а imap — в сегменте данных.
E>А в твоем варианте взятие остатка от деления будет всегда.
Взятие остатка от деления выполняется в регистре, т.е. со скоростью процессора. Без тестирования я совершенно не уверен, кто тут будет быстрее и насколько.

Здравствуйте, Ligen, Вы писали:

Странные выводы из пространной болтовни.

.Net по большому счету это что? Enteprise level, а C++ — это довольно низкий уровень. Ниши использования давно сформировались, имеют довольно четкое разделение и существуют параллельно.
Скорую смерть C++ пророчили еще в середине 90х, когда борланд выпустил дельфю. Стоит ли говорить, что заявлять такое могли только те кто реально в C++ проектах не работал. Сейчас можно оценить качество их предсказаний.
Я давно ушел на .net, но считаю, что кандидата на титул "убийца С++" в обозримом будущем не наблюдается.

Здравствуйте, DarkGray, Вы писали:

E>>А еще более вероятно, что в реальной системе что-то вроде:

DG>И это все шаманство будет быстрее, чем:
DG>return nodes[(idx+2)%3];

Это эквивалентный код, за исключением ошибки с %3, компилер все проинлайнит

K>Это эквивалентный код, за исключением ошибки с %3, компилер все проинлайнит

inline-же это не панацея.
беготня по нескольким разным кускам памяти все равно остается.

Здравствуйте, eao197, Вы писали:

E>Здравствуйте, DarkGray, Вы писали:

E>>>А еще более вероятно, что в реальной системе что-то вроде:

DG>>И это все шаманство будет быстрее, чем:
DG>>return nodes[(idx+2)%3];

E>Думаю, что вполне возможно. Т.к. assert во время отладки удаляет все обращения по неверному индексу. В релизе, с большой вероятностью, все вызовы инлайнятся, а assert изымается, поэтому лишнего оверхеда нет. А в твоем варианте взятие остатка от деления будет всегда.

На самом деле на современных процессорах обмен с памятью -- достаточно дорогая операция.
Так что что тут будет быстрее без исследования вопроса сказать сложно.

Копай Нео, копай -- летать научишься. © Matrix. Парадоксы

Здравствуйте, Кузнецов Денис Викторович, Вы писали:

КДВ>Не обращай внимания. Он по своей дурацкой привычке оппонента зачморить пытается.

Здравствуйте, c-smile, Вы писали:

CS>Если честно то я например устриц не ем.
CS>Мне почему-то достаточно их запаха.

Но, тем не менее, о их вкусе споришь Что и требовалось доказать

Здравствуйте, Шахтер, Вы писали:

E>>Думаю, что вполне возможно. Т.к. assert во время отладки удаляет все обращения по неверному индексу. В релизе, с большой вероятностью, все вызовы инлайнятся, а assert изымается, поэтому лишнего оверхеда нет. А в твоем варианте взятие остатка от деления будет всегда.

Ш>На самом деле на современных процессорах обмен с памятью -- достаточно дорогая операция.

Да. Но и деление никогда не было дешовой операцией. В отличии от сложения или арифметического сдвига.

Ш>Так что что тут будет быстрее без исследования вопроса сказать сложно.

Это точно. Решил посмотреть. Вот чего получилось. Код программы внизу.

capacity: 100000, iterations: 1000
get_via_static_imap duration: 13.75
get_via_local_imap duration: 20.453
get_via_mod duration: 21.203

capacity: 100000, iterations: 100
get_via_static_imap duration: 1.344
get_via_local_imap duration: 2.046
get_via_mod duration: 2.11

capacity: 100, iterations: 100000
get_via_static_imap duration: 1.203
get_via_local_imap duration: 1.907
get_via_mod duration: 1.968

capacity: 1000, iterations: 10000
get_via_static_imap duration: 1.281
get_via_local_imap duration: 1.922
get_via_mod duration: 2.015

capacity: 10000, iterations: 1000
get_via_static_imap duration: 1.187
get_via_local_imap duration: 1.906
get_via_mod duration: 2

Visial C++ 7.1 (-GX -O2).
Intel Pentium M 1.5GHz.

#include <iostream>
#include <string>
#include <vector>
#include <ctime>
#include <cmath>
#include <cstdio>

using namespace std;

class node_t
    {
    private :
        double m_x;
        double m_y;

    public :
        node_t() : m_x( 0 ), m_y( 0 ) {}

        double x() const { return m_x; }
        double y() const { return m_y; }
    };

class triangle_t
    {
    private :
        node_t *    m_nodes[ 3 ];

        static const int imap( int idx )
            {
                static const int m[] = { 1, 2, 0, 1, 2, 0, 1 };
                return m[ idx ];
            }
    public :
        triangle_t( node_t * a, node_t * b, node_t * c )
            {
                m_nodes[ 0 ] = a;
                m_nodes[ 1 ] = b;
                m_nodes[ 2 ] = c;
            }

        const node_t * get_via_static_imap( int idx ) const
            {
                return m_nodes[ imap( idx + 2 ) ];
            }

        const node_t * get_via_local_imap( int idx ) const
            {
                const int m[] = { 1, 2, 0, 1, 2, 0, 1 };
                return m_nodes[ m[ idx + 2 ] ];
            }

        const node_t * get_via_mod( int idx ) const
            {
                return m_nodes[ ( idx + 2 ) % 3 ];
            }
    };

typedef const node_t * (triangle_t:: *pfn_accessor_t)( int idx ) const;

typedef std::vector< node_t > nodes_t;
typedef std::vector< triangle_t > triangles_t;
typedef std::vector< double > results_t;

double
calculate( const triangle_t & t, pfn_accessor_t accessor )
    {
        // Тут какая-то имитация математики.
        return pow( (t.*accessor)( -1 )->x() - (t.*accessor)( 0 )->x(), 2 ) +
            pow( (t.*accessor)( 0 )->x() - (t.*accessor)( 1 )->x(), 2 ) +
            pow( (t.*accessor)( -1 )->y() - (t.*accessor)( 0 )->y(), 2 ) +
            pow( (t.*accessor)( 0 )->y() - (t.*accessor)( 1 )->y(), 2 );
    }

void
meter(
    const std::string & test_case_name,
    const unsigned int iterations,
    const triangles_t & triangles,
    results_t & results,
    pfn_accessor_t accessor )
    {
        std::cout << test_case_name << " " << std::flush;

        std::clock_t start = std::clock();

        for( unsigned int i = 0; i != iterations; ++i )
            {
                for( unsigned int j = 0, j_max = triangles.size();
                        j != j_max; ++j )
                    results[ j ] = calculate( triangles[ j ], accessor );
            }

        std::clock_t finish = std::clock();

        std::cout << "duration: "
                << double( finish - start ) / CLOCKS_PER_SEC
                << std::endl;
    }

void
determine_capacities( int argc, char ** argv,
    unsigned int & capacity,
    unsigned int & iterations )
    {
        const unsigned int default_capacity = 100000;
        const unsigned int default_iterations = 1000;

        capacity = default_capacity;
        iterations = default_iterations;

        if( 3 == argc )
            {
                unsigned int t1, t2;
                if( 1 == sscanf( argv[ 1 ], "%u", &t1 ) &&
                        1 == sscanf( argv[ 2 ], "%u", &t2 ) )
                    {
                        capacity = t1;
                        iterations = t2;
                    }
                else
                    std::cerr << "arguments (" << argv[ 1 ]
                            << ", " << argv[ 2 ] << ") ignored" << std::endl;
            }

        std::cout << "capacity: " << capacity << ", iterations: "
                << iterations << std::endl;
    }

int main( int argc, char ** argv ) 
    { 
        unsigned int capacity;
        unsigned int iterations;
        determine_capacities( argc, argv, capacity, iterations );

        nodes_t nodes( capacity * 3 );
        triangles_t triangles;
        triangles.reserve( capacity );

        results_t results( capacity );

        for( unsigned int i = 0; i != capacity; ++i )
            triangles.push_back(
                    triangle_t(
                            &nodes[ i * 3 ],
                            &nodes[ i * 3 + 1 ],
                            &nodes[ i * 3 + 2 ] ) );

        meter( "get_via_static_imap", iterations, triangles, results,
                &triangle_t::get_via_static_imap );

        meter( "get_via_local_imap", iterations, triangles, results,
                &triangle_t::get_via_local_imap );

        meter( "get_via_mod", iterations, triangles, results,
                &triangle_t::get_via_mod );
    }

Здравствуйте, Sinclair, Вы писали:

E>>Думаю, что вполне возможно. Т.к. assert во время отладки удаляет все обращения по неверному индексу. В релизе, с большой вероятностью, все вызовы инлайнятся, а assert изымается, поэтому лишнего оверхеда нет.
S>Вот тут не понял. Куда изымется второе косвенное обращение? Мы же должны сначала обратиться по адресу imap+idx+2, и прибавить полученное смещение к nodes. При этом nodes лежат очень далеко от imap, потому что они в хипе, а imap — в сегменте данных.

Это при эпизодических обращениях к imap будет справедливо. А если идет пакетная обработка/расчет, когда nodes дергаются постоянно, то imap закешируется.

E>>А в твоем варианте взятие остатка от деления будет всегда.
S>Взятие остатка от деления выполняется в регистре, т.е. со скоростью процессора. Без тестирования я совершенно не уверен, кто тут будет быстрее и насколько.

Так и я не утверждал ничего. Просто сказал, что вполне возможно.
Для своей машины, возможно, угадал: Re[21]: С++ culture

Автор: eao197
Дата: 11.11.05

.

Здравствуйте, c-smile, Вы писали:

CS>Глашатай .Net: От пристал... у нея там думатель унутре. Понял?! И вообще речь не о том!
CS>Главное что порог вхождения низкий...
CS>он: Хм... а я уже здесь как бы. Мне выйти и зайти?

Здравствуйте, VladD2, Вы писали:

ГВ>>Не хотите — не доказывайте, Ваше право. Но и не ждите серьёзного отношения к бездоказательным (сиречь — голосоловным) утверждениям.
VD>Твои утверждения не менее голословны.

Хммм... да... снятие шляпы я ничем доказать не могу. С этим не поспоришь.

VD>Что касается позиций, то я лично наблюдаю другую картину.

[skip, хотя я далеко не согласен]

VD>Короче, этот рассказ можно продолжать еще долго.

Здравствуйте, eao197, Вы писали:

Глянь ещё ассемблер -- очень познавательно.

?get_via_static_imap@triangle_t@@QBEPBVnode_t@@H@Z PROC NEAR ; triangle_t::get_via_static_imap, COMDAT
; _this$ = ecx

; 45   :                 return m_nodes[ imap( idx + 2 ) ];

    mov    eax, DWORD PTR _idx$[esp-4]
    mov    edx, DWORD PTR ?m@?1??imap@triangle_t@@CAHH@Z@4QBHB[eax*4+8]
    mov    eax, DWORD PTR [ecx+edx*4]

; 46   :             }

    ret    4
?get_via_static_imap@triangle_t@@QBEPBVnode_t@@H@Z ENDP    ; triangle_t::get_via_static_imap


?get_via_local_imap@triangle_t@@QBEPBVnode_t@@H@Z PROC NEAR ; triangle_t::get_via_local_imap, COMDAT
; _this$ = ecx

; 49   :             {

    sub    esp, 28                    ; 0000001cH

; 50   :                 const int m[] = { 1, 2, 0, 1, 2, 0, 1 };

    mov    eax, 1
    mov    DWORD PTR _m$[esp+28], eax
    xor    edx, edx
    mov    DWORD PTR _m$[esp+40], eax
    mov    DWORD PTR _m$[esp+52], eax

; 51   :                 return m_nodes[ m[ idx + 2 ] ];

    mov    eax, DWORD PTR _idx$[esp+24]
    mov    DWORD PTR _m$[esp+32], 2
    mov    DWORD PTR _m$[esp+36], edx
    mov    DWORD PTR _m$[esp+44], 2
    mov    DWORD PTR _m$[esp+48], edx
    mov    edx, DWORD PTR _m$[esp+eax*4+36]
    mov    eax, DWORD PTR [ecx+edx*4]

; 52   :             }

    add    esp, 28                    ; 0000001cH
    ret    4
?get_via_local_imap@triangle_t@@QBEPBVnode_t@@H@Z ENDP    ; triangle_t::get_via_local_imap


?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z PROC NEAR    ; triangle_t::get_via_mod, COMDAT
; _this$ = ecx

; 56   :                 return m_nodes[ ( idx + 2 ) % 3 ];

    mov    eax, DWORD PTR _idx$[esp-4]
    add    eax, 2
    push    esi
    cdq
    mov    esi, 3
    idiv    esi
    pop    esi
    mov    eax, DWORD PTR [ecx+edx*4]

; 57   :             }

    ret    4
?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z ENDP        ; triangle_t::get_via_mod

У меня получается

15.3
21.5
27.3

А вот Intel заменяет деление умножением.

?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z    PROC NEAR
; parameter 1(this): ecx
; parameter 2(idx): 8 + esp
$B48$1:                         ; Preds $B48$0
$LN1255:
        push      edi                                           ;55.13
        mov       edi, ecx                                      ;55.13
$LN1256:
        mov       eax, DWORD PTR [esp+8]                        ;54.24
$LN1257:
        lea       ecx, DWORD PTR [eax+2]                        ;56.41
$LN1258:
        mov       eax, 1431655766                               ;56.47
        imul      ecx                                           ;56.47
        mov       eax, ecx                                      ;56.47
        sar       eax, 31                                       ;56.47
        sub       edx, eax                                      ;56.47
        lea       eax, DWORD PTR [edx+edx]                      ;56.47
        add       eax, edx                                      ;56.47
        sub       ecx, eax                                      ;56.47
$LN1259:
        mov       eax, DWORD PTR [edi+ecx*4]                    ;56.24
        pop       edi                                           ;56.24
        ret       4                                             ;56.24
        ALIGN     4
                                ; LOE
; mark_end;
?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z ENDP

И получается побыстрее.

14.9
23.6
18.6

Копай Нео, копай -- летать научишься. © Matrix. Парадоксы

Ох. Тяжело это все-таки.

Но! Одну фразу я все-таки прокомментирую. Умоляю — не надо мне отвечать.

ГВ>Не хотите — не доказывайте, Ваше право. Но и не ждите серьёзного отношения к бездоказательным (сиречь — голосоловным) утверждениям.

Ваши слова о том, что Вы не желаете принимать к сведению мою аргументацию, безапялляционно относя ее к голословной, разбило мне сердце. Я проплакал в подушку всю ночь.

Могу дать еще один безапеляционный совет. Тоже следующий из моего личного опыта и абсолютно бездоказательный.

Если, гуляя по форумам, я вижу, что кто-то гонит пургу, я не отвечаю и не спорю — я просто прохожу мимо. Иногда отпускаю ироничное замечание, которое для понимания требует отсутствие фанатизма в отношении к рассматриваемой теме.
Если кашеобразное состояние головы собеседника выясняется уже в ходе дискуссии, я склонен объяснить свою позицию. Один раз, по мере возможности выбирая простые слова и прибегая к аналогиям из других областей.

Если выясняется, что собеседник имеет свою четкую позицию. в корне отличную от моей — я вступаю в спор и выкладываю свои аргументы. Внимательно выслушиваю аргументы другой стороны. Дискуссия прекрашается, когда я понимаю, что:
— позиция и аргументация собеседника мне понятны
— консенсус найден или не кажется достижимым за разумный период времени

Выхожу из такого разговора я, обогащенный новыми знаниями и расширившимся взглядом на мир. Надеюсь, что это же можно сказать и о моих собеседниках. Хотя это и не главная цель.


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


Всего доброго.

Здравствуйте, Шахтер, Вы писали:

Ш>Здравствуйте, eao197, Вы писали:

Ш>Глянь ещё ассемблер -- очень познавательно.

На ассемблере мне со времени окончания универа не приходилось программировать, так что в ассемблерном коде я вообще слабо чего понял

Самое смешное, что когда я привел Владу код (Re[17]: С++ culture

Автор: eao197
Дата: 10.11.05

), то я совершенно не думал о производительности. Просто написал метод Triangle::node_at(), решил, что это не дело -- нужно еще и константный вариант для симметрии сделать. Начал делать Triangle::node_at() const -- оказалось, что imap дублируется. Сразу же сделал рефакторинг, получилась схема со статическим методом imap. В общем, старался написать красивый код, а он, зараза, еще и быстрым получился. А еще говорят, что красота -- это субъективное понятие :))

Автор: Дарней
Дата: 10.11.05

.