string interpolation VS. string addition

[sape]

EDIT: Fehler überarbeitet! Die Interpolationsvariant ist die schneller von beiden!


Vorsetzung vom Thread: http://www.python-forum.de/topic-8713.html

Falls der Thread im Falschen Sub-Forum ist, dann bitte verschieben.

``s = x[0] + x[1] + ...`` VS. ``s = '%s%s... % (x[0], x[1], ...`` - Geschwindigkeitsmessung

Folgendes Script erzeugt ``output.py``das bei `MAX_OBJ=3` so aussieht. Es hat einmal die ``list`` `obj_list` mit 3 Elementen vom Typ ``str``, bei dem jedes Element genau 2890 Chars lang ist. Weiterhin werden die Funktionen ``f1`` und ``f2`` generiert, dass die Elemente von ``obj_list`` unterschiedlich zurückgibt.


Diese Script...

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time


from mylib.benchmark import Benchmark

t1 = time.clock()
print "Load ``output.py``",
from output import f1, f2
t2 = time.clock() - t1
print "OK (%.2fsec.)" % t2

print "Start Benchmark\n"
bm = Benchmark()

bm.add_function(f1, "return '%s%s... % (x[0], x[1], ...")
bm.add_function(f2, "return x[0] + x[1] + ...          ")
bm.run()
bm.print_ranking()

...lädt ``output.py`` und macht einen Benchmark zwischen ``f1`` und ``f2`` um zu sehen welche Variante schneller ist. Das benötigte Modul ``benchmark`` gibt es hier. Den thread dazu ist findet ihr hier.


Dan nun der Ablauf geklärt ist, hier ein par Benchmarks:

Mit 1000 Elementen (`MAX_OBJ=1000`):

Code: Alles auswählen

Load ``output.py`` OK (0.00sec.)
Start Benchmark

[Die Laufzeit wird ermittelt]
run:      f1 - return '%s%s... % (x[0], x[1], ... OK (1.81sec.)
run:      f2 - return x[0] + x[1] + ...           OK (1.82sec.)

[Ranking wird erzeugt]
Ranking wurde erzeugt.
-------------------------------------------------------------------------------
Funktion: f2 - return x[0] + x[1] + ...           ist am langsamsten; Zeit: 1.819344 sec
Funktion: f1 - return '%s%s... % (x[0], x[1], ... ist um 0.70% schneller; Zeit: 1.806714 sec
-------------------------------------------------------------------------------

Wie man erkenne kann kaum ein Unterschied. Bei mehreren durchläufen ist mal f1 und mal f2 ein wenig schneller Nebenbei sie angemerkt, dass bei ersten ausführen des Scriptes, das laden von ``output.py`` mit 1000 Elementen ungefähr 2.05 Sekunden dauerte. Nach dem daraus eine ``output.pyc`` erzeugt wurde, beim ersten start, beträgt die Ladedauer ~0.0 Sekunden.

Mit 10.000 Elementen (`MAX_OBJ=10000`):
Jetzt wollen wir mal Python zum schwitzen bringen. Achtet mal darauf wie lange es dauert ``output.py`` beim ersten Start zu laden.

Code: Alles auswählen

Load ``output.py`` OK (186.24sec.)
Start Benchmark

[Die Laufzeit wird ermittelt]
run:      f1 - return '%s%s... % (x[0], x[1], ... OK (111.80sec.)
run:      f2 - return x[0] + x[1] + ...           OK (183.74sec.)

[Ranking wird erzeugt]
Ranking wurde erzeugt.
-------------------------------------------------------------------------------
Funktion: f2 - return x[0] + x[1] + ...           ist am langsamsten; Zeit: 183.744273 sec
Funktion: f1 - return '%s%s... % (x[0], x[1], ... ist um 64.35% schneller; Zeit: 111.797196 sec
-------------------------------------------------------------------------------

Das laden des unkompilierten ``output.py`` dauerte ~3 Minuten. ``f1`` ~1,85 Minuten und ``f2`` ~3 Minuten. Somit hat sich meine anfängliche Vermutung dass die Interpolationsvariante ("" % ()) schneller ist doch nun als richtig erwiesen ~65% ist schon viel und mehr als ich vermutet habe


Zweiter durchlaufe, nach dem die ``output.py`` in ``output.pyc`` kompiliert wurde:

Code: Alles auswählen

Load ``output.py`` OK (0.01sec.)
Start Benchmark

[Die Laufzeit wird ermittelt]
run:      f1 - return '%s%s... % (x[0], x[1], ... OK (111.45sec.)
run:      f2 - return x[0] + x[1] + ...           OK (184.55sec.)

[Ranking wird erzeugt]
Ranking wurde erzeugt.
-------------------------------------------------------------------------------
Funktion: f2 - return x[0] + x[1] + ...           ist am langsamsten; Zeit: 184.550015 sec
Funktion: f1 - return '%s%s... % (x[0], x[1], ... ist um 65.58% schneller; Zeit: 111.454085 sec
-------------------------------------------------------------------------------

...

Kleine Erklärung zu der Startdauer von ``output.py`` bei 10.000 Elementen in ``obj_list``, damit auch die letzten zweifler befridigt sind und nicht denken das meine Scripte "Kaputt sind":
Erstmal bedenkt das jeder string in ``obj_lis`` 2890 Zeichen hat (jeder stinrg ist dabei identisch!)! Dan kommt hinzu das 10.000 strings in ``obj_list`` sind Das ergibt 2890000 Zeichen, was eine menge ist. Python kompiliert alle Module bei ersten Start immer in ``.pyc``. Dabei werden gleiche Strings (Also mit gleichen Inhalt) erfasst und alle Objekte die auf den gleiche string "Zeigen" werden auf eben diesen referenziert um Speicherplatz zu Sparen Die ``output.py`` bei 10.000 Elementen ist 27.9MB groß. So eine große Datei zu parsern und dabei alle Mengen der Relation, siehe hier, in eine Menge zusammenzufassen dauert seine Zeit. Also ingrunde werden redundante Mengen zu einer Menge zusammengefast:

Im einfachen Worten bedeutet das, dass im zuvor berechneten LR(1)-Automaten Zustände zusammengeführt werden, deren Kern identisch ist. Der Kern zweier Zustände ist identisch, falls die Items der beiden Zustände bis auf die Follow-Mengen (Lookaheads) identisch sind.

. Ich hoffe ich interpretiere das richtig als nicht Informatiker. Nach dem das fertig ist, ist die output.pyc nur noch 296KB groß, weil alle redundanten strings beseitigt sind und alle 10.000 Elemente von ``obj_list``nur noch auf den einen String zeigen! Damit sollte geklärt sein warum der zweite start nach dem kompilieren nur noch 0.01sec statt 3 Minuten dauert


BTW: Nochmals Sorry das mir dieser peinliche Fehler mit den vertauschten Labels im Benchmarkscript passiert ist.

BTW2: Ich habe alle Testst noch mit deaktivierten GC gemacht und es war kein unterschied in der Geschwindigkeit auszumachen. Schön

P.S.: Als PC kam ein AMD A64 X2 3800 (DualCore) @ 2GHz pro Core zum Einsatz, wobei nur ein Core genutzt wurde, da Python noch nicht SMP Unterstützung bietet.

[rafael]

Anmerkung: Diese Script ladet -> lädt

Das Ergebnis überrascht mich, da in meiner Python Referenz von GE-PACKT steht, dass der Plus-Operator ziemlich viel Rechenzeit auf sich nimmt und man da besser join() nehmen würde.

[BlackJack]

Der Argumentation kann ich nicht folgen. Weil das Buch sagt, dass ``+`` langsamer ist als `join()` darf es nichts geben was noch langsamer ist!?

[rafael]

Ups, hab ich wohl was vergessen

Aber dort steht auch
"Verwenden Sie den Formatierungsoperator % anstelle des Operators +, um einen String aus Einzelheiten zusammenzusetzen.
Ungünstig ist z.B.

Code: Alles auswählen

webseite = "<html>" + head + body + "</html>

Schneller ist:

Code: Alles auswählen

webseite = "<html%s%s</html>" % (head, body)

"

[sape]

[...]dass der Plus-Operator ziemlich viel Rechenzeit auf sich nimmt und man da besser join() nehmen würde.

Ja in schleifen ist das tatsächlich so (Hab noch nicht gemessen aber es wird so gesagt).

Die Variante ist langsamer...

Code: Alles auswählen

foo = ['1', '2', '3'] # ...
bar = ''
for elem in foo:
    bar += elem

...als diese.

Code: Alles auswählen

foo = ['1', '2', '3'] # ...
bar = list()
for elem in foo:
    bar.append(elem)
bar = "".join(bar)

...

BTW: Die Ergebnisse vom Benchmark sollen nicht dazu verleiten das man sich jetzt für die "Addition"-Variante entscheidet Wie man sieht, macht sich das erste bei ungefähr 10.000 Elementen bemerkbar. Keiner würde in der Praxis auf die Idee kommen eine Konkatenation mit 10.000 Elemente zu machen (Nichtmal mit 50 ^^).

Außerdem sollte man auch den Post von Leonidas im anderen Thread beachten, wo er schrieb das man sich immer für die sauberste und übersichtlichste Lösung entscheiden sollte und nicht für eine die am schnellsten ist. (Ausnahme ist bei schleifen. Da sollte man lieber die ``"".join`` Variante nehmen, wie BlackJack schon im Post vom vorigen Thread meinte.)

lg

EDIT: Links zu den Post hinzugefügt.

[sape]

Der Argumentation kann ich nicht folgen. Weil das Buch sagt, dass ``+`` langsamer ist als `join()` darf es nichts geben was noch langsamer ist!?

Stimmt, dass schließt nicht aus das es was langsameres gibt.

Folgende ist aber nach wie vor interessant:

Whenever joining more than two strings, use string interpolation, not addition:

Code: Alles auswählen

s = x + y + z # Bad.
s = '%s%s%s' % (x, y, z) # Good.
s = ''.join([x, y, z]) # Best, but not as general.

This has to do with efficiency; the intermediate string x+y is made (and thus copied) before x+y+z is made, so it's less efficient. People who use string concatenation in a for loop will be swiftly kicked in the head.

http://supybot.com/documentation/help/t ... king/style
http://supybot.com/

Da scheint sich der Autor geirrt zu haben bzw. könnt das ``s = x + y + z`` VS. ``s = '%s%s%s' % (x, y, z)`` nicht von ihm nicht nur in beug auf Performacnce gemeint sein, sondern auch Speicherverbrauch. Er redet da von Effizienz. meinte er damit aber die Geschwindigkeit und/oder Speicherverbrauch? Bei der Interpolationvariante muss mindestens auch temporär was Zwischengespeichert werden wie bei der "Additionsvariante". Ob für die "Additiosvariante" mehrere temporäre Speicherpunkte benutzt werden? Ich denke nicht.

Keine Ahnung. Morgen weiß ich eventuell mehr.

lg und ne gn8
sape

[sape]

Aber dort steht auch
"Verwenden Sie den Formatierungsoperator % anstelle des Operators +, um einen String aus Einzelheiten zusammenzusetzen.
Ungünstig ist z.B.

Code: Alles auswählen

webseite = "<html>" + head + body + "</html>

Schneller ist:

Code: Alles auswählen

webseite = "<html%s%s</html>" % (head, body)

"

Naja, das dachte ich eigentlich auch. Aber ich hallte es nun für ein unhaltbares gerücht. Selbst bei 1000 Objekten die mit ``+`` zusammengefügt und ``%`` ist keine wirklich schneller. Hab mit 1000 Objekten ca. 10 Runs gemacht und der unterscheid betrug immer ca. 0.01sec biw 0.03sec. Mysteriös wird es aber wie man sieht bei 10.000 Keine Ahnung warum das so ist. Aber egal, das ist ehe weit entfernt jeder Praxis.

lg

[Python 47]

Gut das du dir die Mühe machst, das alles zu überprüfen, aber ich verstehe nicht, was dich an der Sache so fasziniert, mind. 10 Posts(In diesen und im anderen Thread) zu posten. Kannst du mir das evt. erklären?

[cracki]

edit: @sape, mich nervts auch dass du ueberall mehrere posts hintereinander schreibst. benutz die editfunktion. dafuer ist sie da.

sape, leider kann ich deine scripts nicht sehen, weil pocoo gerade kaputt ist.

von dem was die anderen sagen kann ich aber doch ableiten, dass deine benchmarks sehr kaputt sind. ein script das 3 minuten zum laden braucht, das kann nur kaputt sein.

dazu kommt, dass du mit python nicht die noetige erfahrung hast. du wuesstest also garnicht, wie du zu benchmarkenden code so schreibst, dass du auch das messen kannst was du willst.

wenn die scripte mal verfuegbar sind, guck ich sie mir nochmal an und geb meinen senf dazu...

[birkenfeld]

sape, leider kann ich deine scripts nicht sehen, weil pocoo gerade kaputt ist.

Hu?

[Leonidas]

sape, leider kann ich deine scripts nicht sehen, weil pocoo gerade kaputt ist.

Hu?

Er meint eigentlich LodgeIt. So gibt dieser Link eine ViewDoesNotExist-Exception:

Code: Alles auswählen

ViewDoesNotExist: Tried pastebin.static.views.error500. Error was: 'tuple' object has no attribute 'lower'
      args = ("Tried pastebin.static.views.error500. Error was: 'tuple' object has no attribute 'lower'",)

[sape]

Gut das du dir die Mühe machst, das alles zu überprüfen, aber ich verstehe nicht, was dich an der Sache so fasziniert, mind. 10 Posts(In diesen und im anderen Thread) zu posten. Kannst du mir das evt. erklären?

Was mich an der Sache interessiert ist schnell erklärt.
1. Erstmal bin ich generell ein Fan von Benchmarks (CPU, RAM, Graka, etc).
2. Zweitens Interessiert mich generell wieviel Geschwindigkeit und benötigten Speichermenge eine Sachen X in Python benötigt.
3. Zweitens ist für mich insofern relevant, damit ich nachehr für einen Testinterpreter (Geschrieben in Python. Als LALR-Parser kommt Pyparsing zum Einsatz, das relatiev Simple ist.), die effizientesten Bytecode nutze um so wenig Speicher wie nötig brauche und auch die schnellste Variante nutze. psyco wird selbstverständlich auch für einen Geschwindigkeitsbost vom Lexerteil der mit Pyparsing implementiert ist genutzt und für die Interpretereinheit.

edit: @sape, mich nervts auch dass du ueberall mehrere posts hintereinander schreibst. benutz die editfunktion. dafuer ist sie da.

Komisch, bisher hat mich kein Moderator oder Administrator darauf angesprochen. Davon abgesehen ist es in diesem Forum gestatte Doppel, Dreifach, etc Posts zu machen und nicht wie in anderen Foren. Davon machen auch die Mods und Admins gebrauch.

von dem was die anderen sagen kann ich aber doch ableiten, dass deine benchmarks sehr kaputt sind. ein script das 3 minuten zum laden braucht, das kann nur kaputt sein.

Warum machst du dir nicht die mühe und leist dir meine Post durch? Es wird eine Liste erzeugt mit 10.000 (In Worten Zehntausend) Elementen von dem JEDES Element einen string hat der 3000 Zeichen enthält. Nun frage dich mal selber wie lange das dauert im nicht kompilierten Zustand! Dan wird jedes Element in ``+`` und in ``%s%s... %(...`` verfahren returned. Das alles ist auch dem Post zu entnehmen aber nur wenn man sich die Mühe macht den Post zu Lesen und ihn auch zu verstehen, da er sehr Komprimiert ist und ich auch davon ausgehe das man die Scripts und deren Vorgang versteht (Und die Basics in Python).

Also nochmal als Pseudocode:

Code: Alles auswählen

obj_list = [# Ein String mit 3000 Zeichen der erste#, #... er Zweite#, ...,
                #.... der 9999ste#]
def f1():
   return obj_list[0] + obj_list[1] + obj_list[2] + ... + obj_list[9999]

def f2():
    .... # das gleiche bolss als Interpolation -> ``%s%s... % (...``

Nun sollte es klarer sein. Und glaub mir, eine ``list`` mit 10.000 Elementen wo jedes Ellement 3000 Zeichen enthält braucht in nicht kompilierten Zustand ca. 3 Minuten für das Laden

dazu kommt, dass du mit python nicht die noetige erfahrung hast. du wuesstest also garnicht, wie du zu benchmarkenden code so schreibst, dass du auch das messen kannst was du willst.

Ich glaube das kannst Du nicht beurteilen, wie viel Erfahrung ich habe.

wenn die scripte mal verfuegbar sind, guck ich sie mir nochmal an und geb meinen senf dazu...

Ja, das solltest du wirklich bevor du mich unberechtigterweise der Unwissenheit bezichtigst. BTW: Ich habe kein Problem damit wenn mir jemand sagt das die Ergebnisse Käse sind (im gegenteil wenn was Falsch ist, möchte ich sogar darauf hingewiesen werden, damit ich was draus Lerne und es nächstes mal besser mache.). Aber wenn man sowas macht, dann sollte man sich die Mühe machen erstmal die Ergebnisse zu Analysieren (Post richtig lesen, das gelesen Verstehen, selber Tests aufstellen, etc..) und dann Argumente vorbringen und __nicht__ solche Sachen wie "Du hast ehe keine Erfahrung => Du bist ein N00b"


Davon mal abgesehen: Die mühe mache ich mir sowieso. Und wenn ich das schon mache, kann ich ja auch meine Ergebnisse Postenund andere daran teilhaben lassen. Eventuell ergibt sich sogar das es wirklich brauchbar ist oder eben das es vollkommen Falsch ist. Dann kann man überlegen wie man das am besten anders macht (Wie zum Beispiel der Vorschlag von Y0GI)

Wenn es jemanden stört, kann er ja diesen Thread ignorieren. Falls es einen Administrator stört (was ich sehr bezweifle) dann kann er den Thread gerne schließen. Damit habe ich kein Problem und respektiere die Entscheidung.

Danke fürs zuhören, falls du dir den Post nicht so durchgelesen hast wie den ersten

lg

BTW: Der Grund warum ich einen neuen Thread aufgemacht habe ist, das der andere angefangen hat langsam zu Blockieren (phpBB sag ich da nur). Die Post Vorschau und das abschicken eines Postes hat zu Lange gedauert.

[sape]

Scheiße! Ich habe die Labels der Funktionen im Benchmark vertauscht gehabt! Mist!...

Die Interpolationsvariante ist doch schneller als die "Additionsvariante"!

Sorry, ich hoffe es nimmt mir keiner übel Werde den Post jetzt schnell überarbeiten und das geänderte Script neu uploaden.

EDIT: Fertig Habe alle Benchmarks noch mal neu gemacht und den ersten Post editiert. Noch mal Sorry mit den Vertauschten Labels. BTW: Kein unterschied mit oder ohne GC

lg

EDIT:
Was ist eigentlich mit LodgeIt los Ging doch gestern noch alles ohne Probleme.

[cracki]

sape:

du erzeugst eine riesige source datei anstatt die strings zur laufzeit zu erzeugen. klar brauchts laden da unmengen von zeit.

deine benchmarks beruhen auf monstroesen formatstrings. wie waers wenn du kleine formatstrings nimmst, dafuer aber mehrere tausend iterationen misst und dann die zeiten vergleichst?

dazu kommt, dass du mit python nicht die noetige erfahrung hast. du wuesstest also garnicht, wie du zu benchmarkenden code so schreibst, dass du auch das messen kannst was du willst.

Ich glaube das kannst Du nicht beurteilen, wie viel Erfahrung ich habe.

lieg ich denn sooo falsch mit meiner vermutung?

[mitsuhiko]

sape, leider kann ich deine scripts nicht sehen, weil pocoo gerade kaputt ist.

Hu?

Er meint eigentlich LodgeIt. So gibt dieser Link eine ViewDoesNotExist-Exception:

fixed

[sape]

sape:

du erzeugst eine riesige source datei anstatt die strings zur laufzeit zu erzeugen. klar brauchts laden da unmengen von zeit.

Ich geb es auf. Du hast es nicht begriffen. -> Kuckst du Sourcecode!

deine benchmarks beruhen auf monstroesen formatstrings. wie waers wenn du kleine formatstrings nimmst, dafuer aber mehrere tausend iterationen misst und dann die zeiten vergleichst?

Es geht nicht darum die Interpolatiosvariante gegen die Additionsvariante in mehreren Tausenden Iterationen zu messen, sondern außerhalb einer schleife. Das was du meinst wurde bereits schon gemacht. Es soll lediglich gemessen werden wie lange ein ``return x + y + z + ...`` braucht und wie lange ``return "%s%s%s ... %(x, y, z ...``. Ist der Quelletext den so unverständlich? Sind meine Erklärungen DEN SO unverständlich??

dazu kommt, dass du mit python nicht die noetige erfahrung hast. du wuesstest also garnicht, wie du zu benchmarkenden code so schreibst, dass du auch das messen kannst was du willst.

Ich glaube das kannst Du nicht beurteilen, wie viel Erfahrung ich habe.

lieg ich denn sooo falsch mit meiner vermutung?

Ja!

[birkenfeld]

sape, leider kann ich deine scripts nicht sehen, weil pocoo gerade kaputt ist.

Hu?

Er meint eigentlich LodgeIt. So gibt dieser Link eine ViewDoesNotExist-Exception:

fixed

testcase added

[cracki]

sape:
eine "29 MB" grosse .py datei zu erzeugen ist doch schon ein bisschen albern, nicht?
warum wolltest du die strings nicht zur laufzeit erzeugen? waer viel schneller gegangen.

[Python 47]

@Sape:

Glaub mir ich kenn cracki gut genug um beurteilen zu können das er zu 99% Recht mit seinen Posts hat, um es genau zu sagen, habe ich es noch nie erlebt, das cracki falschen/schlechten Source Code gepostet oder in seiner Antwort falsch lag, in diesem, wie auch in anderen Boards.

Und es ist auch sinnlos, dass du mit cracki diskutierst, da er eh Recht hat.

Und woran er es erkennen kann, das du noch nicht viel Erfahrung mit der Sprach hast? Ganz einfach an deinen geposteten Codes.

Das hier soll kein Post sein, der sich gegen Sape richtet.

[sape]

Glaub mir ich kenn cracki gut genug um beurteilen zu können das er zu 99% Recht mit seinen Posts hat,

Hab mir seine bisherigen Post durchgelesen. Ich denke die sprechen für sich.

Und um zu beurteilen ob einer zu 99% immer recht hat, muss man entweder genauso gut oder besser sein. Ich kann mir nicht vorstellen, das du oder ich oder sonstwer beurteilen können, das er in jeden Gebiet immer zu 99% Recht hat. Dazu sind die Interessen zu unterschiedlich. Und selbst wenn ihr die gleiche Interessen habt, müsstest du in genau diesen Interesengebieten genauso (oder gar besser) bescheid Wissen um auf so eine Meinung zu kommen.

Ist das der Fall bei dir oder spricht da nur die pure Sympatie aus dir?

um es genau zu sagen, habe ich es noch nie erlebt, das cracki falschen/schlechten Source Code gepostet

1. Falschen Sourcecode? -> Nein, habe ich auch noch nicht bei ihm gesehen.
2. Unpassenden Sourcecode -> Ja.
3. Schlechten Sourcecode -> Auch ja.

Davon abgesehen habe ich auch schon schlechten und unpassenden (Weil ich einen Post nicht verstanden habe) Code gepostet. Und mal nebenbei: Hier sind viele Python-Profis die auch schon mal schlechten und unpassenden Code gepostet habe, das sich oft erst gegen ende eines Threads ergeben hat Und ich rede hier wirklich von den richtigen Profis -> Niemand ist unfehlbar. Jeder macht Fehler.

Daher würde ich an deiner stelle nicht in seinen Namen Sprechen, da ich glaube das er selber nicht will, dass du eine Meinung über ihn verbreitest die er selber so nicht sehen will. -> So nach dem Motte: "Ich bin unfehlbar" <- Ich glaube kaum das er selber von sich so anmaßend denkt.

oder in seiner Antwort falsch lag, in diesem, wie auch in anderen Boards.

Ich habe es schon erlebt. Und? Ist ja nichts schlimmes. Dagegen ist keiner gewappnet.

Und es ist auch sinnlos, dass du mit cracki diskutierst, da er eh Recht hat.

Man beachte das Wort "eh" in deinem Satz.

Kannst du das auch begründen warum er eh Recht hat? Kannst du nachvollziehen warum er recht hat? Oder hat er deiner Meinung nach immer Recht, egal was die anderen Sagen? Bist du nicht ein wenig voreingenommen?

Heißt das, egal was cracki sagt, ich habe nicht das Recht mit ihm zu diskutieren, weil er immer Recht hat (Wie gesagt man beachte das Wort "eh" in deinem Satz)? -> Auch hier würde ich dir empfehlen, nicht in seinem Namen so eine Aussage zu machen, da ich mir beim besten willen nicht vorstellen kann das er möchte das du so einen scheiß über ihm verbreitest. Den ich glaube kaum das cracki sich als einen Menschen sieht der immer (oder ehe ) recht hat.

Und woran er es erkennen kann, das du noch nicht viel Erfahrung mit der Sprach hast? Ganz einfach an deinen geposteten Codes.

Woher weißt du das er genau dass als Grundlage genommen hat? Er hat doch schon angefangen über da Thema zu reden und sich eine "Meinung" gebildet (basierend auf einem Vorurteil), bevor er meinen Code gelesen hat, und nebenbei bemerkt, bevor er meine Post richtig gelesen hatte. Erst später, nach dem er das erledigt hatte, war eine vernümftige Diskussion möglich, da er sich mit den Code und den Fakten auseinander gesetzt hatte. Aber davor, war das nur eine Wertung ohne jeglicher Grundlage (Vorurteil), da er sich nicht die Mühe gemacht hatte vorab erstmal alles zu Analysieren, bevor er eine Behauptung aufstellt (Was sehr unprofessionelle ist.).

Das hier soll kein Post sein, der sich gegen Sape richtet.

Okay, eigentlich wollte ich folgendes nicht schreiben. Aber da Du nun mit diesem Satz "Subtil" damit anfängst in dem Du extra betonst dass sich dein Post nicht gegen mich richtet, kann ich nur davon ausgehen dass der Post genau das bezwecken soll, da man sowas nicht extra erwähnen braucht, wenn es nicht der Fall ist. = Wenn sich der Post nicht gegen mich richten würde dann bräuchtest du das auch nicht zu erwähnen, was du aber nun gemacht hast.

Du sagst der Post richtet sich nicht gegen mich. Ich sage, doch soll es und ich weiß auch warum Es geht um die Differenz die wir beiden hatten, die vor dem öffnen diese Threads zwischen uns begann. Daher schlage ich dir vor, dass wir unsere Differenzen per PN oder ICQ aus der Welt schaffen und uns nicht auf so ein Niveau herablassen. Was hältst du davon? Es kann ja nicht angehen, das du jetzt anfängst in jeden Thread in dem ich poste, etwas zu schreiben das sich gegen mich richtet, nur weil du dich unberechtigterweise von mir angepisst gefühlt hast Und ehrlich, ich habe auch keine Lust drauf da mitzumachen. Aus dem Alter bin ich lägst raus.

Ich könnte dich Ignorieren. Wahrlich, das wäre das einfachste. Da ich aber kein Mensch bin der andere Ignoriert (da ich sowas echt scheiße finde), würde ich lieber erst Probieren unsere Streitigkeiten wie Erwachsene Menschen zu klären.

Daher las uns unseren Disput, in einem privaten klärenden Gespräch, aus der Welt schaffen. Alles andere führt zu nichts.

lg
sape

P.S.: Danke fürs zuhören.