Re[2]: Коробочные продукты на .NET (НЕ для программистов/адм - Компьютерные священные войны

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

kuj>>Алгоритм описывает последовательность действий, но при этом детали реализации этой в разных языках, ессесно, разнятся. Короче, хаттаб, полный слив тебе засчитан.

H>Наконец до тебя дошло. Мои поздравления. Ничего, что я об этом раз десять уже написал?

Нет, ты писал, что алгоритм идентичен, когда это не так. Открой исходник string operator+ и прозрей. ;] Подозреваю, что в виду ограниченности ты этого сделать не сможешь, потому разжую тебе:

Делфи: при конкатенации строк изменяется внутренний буфер той, которой идет присваивание на величину равную длине второго операнда, затем выполняется memcpy из буфера второго операнда. Новых объектов не создается.
С#: при конкатенации двух строк в виду неизменяемой природы строки создается третья строка, которая заполняется содержимым буфера первого и второго операнда. COW, иными словами.

Короче, повторяю: слив засчитан, хаттаб.

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

H>>Для тех кто не понял, я повторю еще раз: это был пример демонстрирующий всю бессмысленность стремления к идентичности алгоритмов, ибо вот такие детали реализаций будут торчать изо всех щелей.

C>Ну это глупости. Если вместо string использовать StringBuilder, то алгоритм от этого не поменяется. Поменяется способ реализации алгоритма. Вы, например, знаете что такое "рефакторинг"? Если знаете, то поймете что я имею в виду...

Чудно. Если вместо базового набора инструкций x86 использовать расширения типа MMX и SSEx, в алгоритме тоже ничего не изменится, кроме перформанса (а именно отсюда все споры об идентичности). Идентичность просто не достижима, и это медицинский факт.

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

kuj>>>Алгоритм описывает последовательность действий, но при этом детали реализации этой в разных языках, ессесно, разнятся. Короче, хаттаб, полный слив тебе засчитан.

H>>Наконец до тебя дошло. Мои поздравления. Ничего, что я об этом раз десять уже написал?

kuj>Нет, ты писал, что алгоритм идентичен, когда это не так. Открой исходник string operator+ и прозрей. ;]

Алгоритм идентичен. Выполняемая работа нет. Я ровно это и сказал. Ты снова на веществах?

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

Y>>Говоря про естественность ты имеешь в виду выглядит одинаково?

Твоя реализация алгоритма выглядит неестественно для C#, если что.

H>Говоря о естественности, я в первую очередь говорю о том, что строки таки складываются со строками.

Во-первых, к идентичности алгоритма это отношение не имеет. Во-вторых смотри выделенное выше.

H>Мутабельные они или нет, важно лишь для .NET.

Это важно для идентичности алгоритмов.
А мутабельность строки также важна в приведенной пенисометрии для Delphi как и для .Net

Y>>Еще раз: задача была привести аналогичные алгоритмы, а не алгоритмы, кажущиеся естественными тебе или алгоритмы использующие базовые типы (StringBuilder находиться в Base Class Library, если что).
Y>>А теперь давай по простому, может тогда поймешь:
Y>>Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Y>>Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

H>StringBuilder это спец. заточка на перформанс ценой мемори-оверхеда. В Delphi все строки плоские, с оверхедом 14 байт. И ты мне говоришь, что это будет идентичное сравнение

Я говорю что это будут идентичные алгоритмы. И только в этом случае уже имеет смысл сравнение кто где оверхедом страдает, кто тормоз и вообще у кого длиннее. Ты же, кстати, для сравнения выбрал скорость, а не потребляемую память, нет?

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

Y>>>Говоря про естественность ты имеешь в виду выглядит одинаково?

Твоя реализация алгоритма выглядит неестественно для C#, если что.

H>>Говоря о естественности, я в первую очередь говорю о том, что строки таки складываются со строками.

Y>Во-первых, к идентичности алгоритма это отношение не имеет. Во-вторых смотри выделенное выше.

Как же не имеет, когда в одном случае используются именно строки, а в другом ты предлагешь использовать специально ориентированную на перформанс структуру?

H>>Мутабельные они или нет, важно лишь для .NET.

Y>Это важно для идентичности алгоритмов.

Это ни как не отражается на алгоритме, это отражается на выполняемой работе уровнем ниже.

Y>А мутабельность строки также важна в приведенной пенисометрии для Delphi как и для .Net

Это не пенисометрия...

Y>>>Еще раз: задача была привести аналогичные алгоритмы, а не алгоритмы, кажущиеся естественными тебе или алгоритмы использующие базовые типы (StringBuilder находиться в Base Class Library, если что).
Y>>>А теперь давай по простому, может тогда поймешь:
Y>>>Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Y>>>Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

H>>StringBuilder это спец. заточка на перформанс ценой мемори-оверхеда. В Delphi все строки плоские, с оверхедом 14 байт. И ты мне говоришь, что это будет идентичное сравнение

Y>Я говорю что это будут идентичные алгоритмы. И только в этом случае уже имеет смысл сравнение кто где оверхедом страдает, кто тормоз и вообще у кого длиннее. Ты же, кстати, для сравнения выбрал скорость, а не потребляемую память, нет?

Это не будет идентичным алгоритмом по причине использования разнородных сущностей. Я ничего не сравнивал и не сравниваю (даже сама идея сравнения строк принадлежит не мне!), это был простой пример показывающий бессмысленность стремления к идентичности алгоритмов. Сколько еще раз я должен это написать?

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

H>Это не будет идентичным алгоритмом по причине использования разнородных сущностей.

Еще раз:

Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

В каком из вариантов ты видишь использование разнородных сущностей, а в каком однородных?

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

H>>Это не будет идентичным алгоритмом по причине использования разнородных сущностей.

Y>Еще раз:
Y>

Y>Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Y>Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

Y>В каком из вариантов ты видишь использование разнородных сущностей, а в каком однородных?

Строки Delphi и строки .NET. Не классы со сложным внутренним представлением строки, а именно, непосредствено, строки.

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

H>>>Это не будет идентичным алгоритмом по причине использования разнородных сущностей.

Y>>Еще раз:
Y>>

Y>>Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Y>>Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

Y>>В каком из вариантов ты видишь использование разнородных сущностей, а в каком однородных?

H>Строки Delphi и строки .NET. Не классы со сложным внутренним представлением строки, а именно, непосредствено, строки.

Ну и что ты пытаешься доказать? Что mutable строки Delphi быстрее выполняют конкатенацию, чем immutable строки дотнет? Это как бэ by design фича. Поэтому строки в дотнет разделены по функциям на неизменяемый класс String и вспомогательный класс StringBuilder для быстрой конкатенации. Говоря иначе, везде, где требуется выполнять большое количество модификаций в строке используется StringBuilder, и скорости он дает такую, что С++ и Delphi скромно курят в сторонке — особенно на replace`ах. ;]
Ты об этом не знал? Будешь знать. ;]

Судя по тому, как ты путаешь алгоритм и конкретную реализацию специального образования ты не получал и книг не читал. Профнепригоден, иными словами.

Здравствуйте, hattab, Вы писали:
H>>>Это не будет идентичным алгоритмом по причине использования разнородных сущностей.
Y>>Еще раз:
Y>>

Y>>Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Y>>Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

Y>>В каком из вариантов ты видишь использование разнородных сущностей, а в каком однородных?

H>Строки Delphi и строки .NET. Не классы со сложным внутренним представлением строки, а именно, непосредствено, строки.

Тебя просили идентичный алгоритм, а не сравнение яблок с помидорами. Сравнивать класс String в Delphi с классом String в .Net — это твоя самодеятельнось.
Напомнить как все было?

J>Зачем мне твои тесты? Меня и так все устраивает. Но если хочется сранивать производительность c++ и .net кода то гораздо логичнее делать это с помощью каких-то идентичных реализаций алгоритмов.
H>Взять хотя бы последнюю синтетику со сравнением строк. Взять конкатенацию. Обычные строки Delphi идут наровне со специализированным классом StringBuilder в .NET. А если использовать идентичный алгоритм -- взять строки .NET? Просядет .NET на порядок? На два?

Я выделил твои же слова. Из них ведь так очевидно следует, что взять String из .Net — это будет идентичный алгоритм, правда?

__________________________________________________________________________________________
З.Ы.
Более того, даже с этой задачей (сравнить яблоки с помидорами) ты справился на двоечку.

var timer = new Stopwatch();
timer.Start();
string s = string.Concat(Enumerable.Repeat("c1", 100000).ToArray());
timer.Stop();
Console.WriteLine("result: elapsed {0} ({1})", timer.ElapsedMilliseconds, s.Length);

На моем компе результат result: elapsed 9 (200000)
При этом проводя в ToArray() больше времени, чем в Concat()

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

kuj>Ну и что ты пытаешься доказать? Что mutable строки Delphi быстрее выполняют конкатенацию, чем immutable строки дотнет? Это как бэ by design фича. Поэтому строки в дотнет разделены по функциям на неизменяемый класс String и вспомогательный класс StringBuilder для быстрой конкатенации. Говоря иначе, везде, где требуется выполнять большое количество модификаций в строке используется StringBuilder, и скорости он дает такую, что С++ и Delphi скромно курят в сторонке — особенно на replace`ах. ;]

С какой радости? Тот же массив чаров (в одном, правда, это символы, в другом байты, но не суть важно), что в .NET StringBuilder, что в C++ std::string. Алгоритмическая сложность replace будет та же самая.

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

Y>__________________________________________________________________________________________
Y>З.Ы.
Y>Более того, даже с этой задачей (сравнить яблоки с помидорами) ты справился на двоечку.
Y>

Y>var timer = new Stopwatch();
Y>timer.Start();
Y>string s = string.Concat(Enumerable.Repeat("c1", 100000).ToArray());
Y>timer.Stop();
Y>Console.WriteLine("result: elapsed {0} ({1})", timer.ElapsedMilliseconds, s.Length);
Y>

Y>На моем компе результат result: elapsed 9 (200000)
Y>При этом проводя в ToArray() больше времени, чем в Concat()

Дабы избежать возможных дебатов по выделенному, перепишу:

var timer = new Stopwatch();
            timer.Start();
            var source = new string[100000];
            for (int i = 0; i < 100000; i++)
            {
                source[i] = "c1";
            }
            var s = string.Concat(source);
            timer.Stop();
            Console.WriteLine("result: elapsed {0} ({1})", timer.ElapsedMilliseconds, s.Length);

result: elapsed 2 (200000)

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

H>>Строки Delphi и строки .NET. Не классы со сложным внутренним представлением строки, а именно, непосредствено, строки.

kuj>Ну и что ты пытаешься доказать?

Еще раз, для тебя, умника: я ничего не сравнивал. Научись уже читать и улавливать смысл.

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

Y>>>В каком из вариантов ты видишь использование разнородных сущностей, а в каком однородных?

H>>Строки Delphi и строки .NET. Не классы со сложным внутренним представлением строки, а именно, непосредствено, строки.

Y>Тебя просили идентичный алгоритм, а не сравнение яблок с помидорами. Сравнивать класс String в Delphi с классом String в .Net — это твоя самодеятельнось.

Это и есть идентичный алгоритм, а ни какая не самодеятельность. Строки со строками, вполне естественно.

Y>Напомнить как все было?

Y>

J>>Зачем мне твои тесты? Меня и так все устраивает. Но если хочется сранивать производительность c++ и .net кода то гораздо логичнее делать это с помощью каких-то идентичных реализаций алгоритмов.
H>>Взять хотя бы последнюю синтетику со сравнением строк. Взять конкатенацию. Обычные строки Delphi идут наровне со специализированным классом StringBuilder в .NET. А если использовать идентичный алгоритм -- взять строки .NET? Просядет .NET на порядок? На два?

Y>Я выделил твои же слова. Из них ведь так очевидно следует, что взять String из .Net — это будет идентичный алгоритм, правда?

Как раз таки наоборот. criosray сравнил сишную std:string с .NET'овским StringBuilder'ом. Я по аналогии сделал сравнение со строками Delphi, но это был вовсе не идентичный алгоритм. В выделеном, я как раз и говорю, что даже при использовании спец.класса ориентированного на перформанс, обычные строки Delphi при конкатенации ему ничуть не уступают. А далее говорю, что если сделать алгоритм идентичным...

Y>__________________________________________________________________________________________
Y>З.Ы.
Y>Более того, даже с этой задачей (сравнить яблоки с помидорами) ты справился на двоечку.
Y>

Y>var timer = new Stopwatch();
Y>timer.Start();
Y>string s = string.Concat(Enumerable.Repeat("c1", 100000).ToArray());
Y>timer.Stop();
Y>Console.WriteLine("result: elapsed {0} ({1})", timer.ElapsedMilliseconds, s.Length);
Y>

Y>На моем компе результат result: elapsed 9 (200000)
Y>При этом проводя в ToArray() больше времени, чем в Concat()

На моем 24, вот только складываешь ты не строки.

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

kuj>>Ну и что ты пытаешься доказать? Что mutable строки Delphi быстрее выполняют конкатенацию, чем immutable строки дотнет? Это как бэ by design фича. Поэтому строки в дотнет разделены по функциям на неизменяемый класс String и вспомогательный класс StringBuilder для быстрой конкатенации. Говоря иначе, везде, где требуется выполнять большое количество модификаций в строке используется StringBuilder, и скорости он дает такую, что С++ и Delphi скромно курят в сторонке — особенно на replace`ах. ;]

WF>С какой радости? Тот же массив чаров (в одном, правда, это символы, в другом байты, но не суть важно), что в .NET StringBuilder, что в C++ std::string. Алгоритмическая сложность replace будет та же самая.

У StringBuilder'а двукратный оверхед по памяти, какой же там массив чаров?

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

Y>>При этом проводя в ToArray() больше времени, чем в Concat()

Y>Дабы избежать возможных дебатов по выделенному, перепишу:
Y>

Y>var timer = new Stopwatch();
Y>            timer.Start();
Y>            var source = new string[100000];
Y>            for (int i = 0; i < 100000; i++)
Y>            {
Y>                source[i] = "c1";
Y>            }
Y>            var s = string.Concat(source);
Y>            timer.Stop();
Y>            Console.WriteLine("result: elapsed {0} ({1})", timer.ElapsedMilliseconds, s.Length);
Y>

Y>result: elapsed 2 (200000)

И сколько тут операци конкатенации?

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

H>Это и есть идентичный алгоритм, а ни какая не самодеятельность. Строки со строками, вполне естественно.
Это не идентичный алгоритм. Так как ты сравниваешь мутабельные строки с иммутабельными.

H>Как раз таки наоборот. criosray сравнил сишную std:string с .NET'овским StringBuilder'ом. Я по аналогии сделал сравнение со строками Delphi, но это был вовсе не идентичный алгоритм. В выделеном, я как раз и говорю, что даже при использовании спец.класса ориентированного на перформанс, обычные строки Delphi при конкатенации ему ничуть не уступают. А далее говорю, что если сделать алгоритм идентичным...

Не сливай так откровенно.
Идентичный алгоритм — тот который использует объекты с одинаковым предназначением, а не с одинаковым названием.

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

H>У StringBuilder'а двукратный оверхед по памяти, какой же там массив чаров?

В огороде бузина, а в Киеве дядька?

У std::string длина строки и capacity тоже могут не совпадать. Как там в Delphi — не в курсе.

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

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

Y>>>При этом проводя в ToArray() больше времени, чем в Concat()

Y>>Дабы избежать возможных дебатов по выделенному, перепишу:

H>

И сколько тут операци конкатенации?

Ты читать умеешь? Я написал для чего я переписал код. Могу добавить выделение, так понятней?

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

H>>>Строки Delphi и строки .NET. Не классы со сложным внутренним представлением строки, а именно, непосредствено, строки.

kuj>>Ну и что ты пытаешься доказать?

H>Еще раз, для тебя, умника: я ничего не сравнивал. Научись уже читать и улавливать смысл.

Я ржал. Теперь он уже ничего не сравнивал. Написал фигню, ткнули носом в фигню, а теперь вместо того, чтоб скромно в сторонке обтекать да обсыхать, пытаешься съехать с темы.

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

Y>>>>В каком из вариантов ты видишь использование разнородных сущностей, а в каком однородных?

H>>>Строки Delphi и строки .NET. Не классы со сложным внутренним представлением строки, а именно, непосредствено, строки.

Y>>Тебя просили идентичный алгоритм, а не сравнение яблок с помидорами. Сравнивать класс String в Delphi с классом String в .Net — это твоя самодеятельнось.

H>Это и есть идентичный алгоритм, а ни какая не самодеятельность. Строки со строками, вполне естественно.

"Я ничего не сравнивал"

Y>>Я выделил твои же слова. Из них ведь так очевидно следует, что взять String из .Net — это будет идентичный алгоритм, правда?

H>Как раз таки наоборот. criosray сравнил сишную std:string с .NET'овским StringBuilder'ом. Я по аналогии сделал сравнение со строками Delphi, но это был вовсе не идентичный алгоритм. В выделеном, я как раз и говорю, что даже при использовании спец.класса ориентированного на перформанс, обычные строки Delphi при конкатенации ему ничуть не уступают. А далее говорю, что если сделать алгоритм идентичным...

"Я ничего не сравнивал"

Y>>__________________________________________________________________________________________
Y>>З.Ы.
Y>>Более того, даже с этой задачей (сравнить яблоки с помидорами) ты справился на двоечку.
Y>>

Y>>var timer = new Stopwatch();
Y>>timer.Start();
Y>>string s = string.Concat(Enumerable.Repeat("c1", 100000).ToArray());
Y>>timer.Stop();
Y>>Console.WriteLine("result: elapsed {0} ({1})", timer.ElapsedMilliseconds, s.Length);
Y>>

Y>>На моем компе результат result: elapsed 9 (200000)
Y>>При этом проводя в ToArray() больше времени, чем в Concat()

H>На моем 24, вот только складываешь ты не строки.
А что же он складывает?

Продолжай самоопускаться хаттабик, это становится смешно. ;]

	От:	kuj
	Дата:	14.06.09 19:06
	Оценка:

	От:	hattab
	Дата:	14.06.09 19:21
	Оценка:

	От:	hattab
	Дата:	14.06.09 19:21
	Оценка:

	От:	yuriylsh
	Дата:	14.06.09 19:38
	Оценка:	+1

	От:	hattab
	Дата:	14.06.09 20:01
	Оценка:	-1

От:	gandjustas	http://blog.gandjustas.ru/
Дата:	15.06.09 04:38
Оценка:	1 (1) +2