ZFX + Developia

Ich hab die Erfahrung gemacht, dass FindInFiles in VS generell (beobachtet bei 2005 und 2008) nicht sonderlich zuverlässig funktioniert und nutze für grössere Suchen eher einen passablen Editior wie Notepad++ :x Bisher dachte ich nur ich bediene das Ding falsch aber ich scheine ja nicht der einzige mit Problemen zu sein.

Seltsam, obwohl mir auf Arbeit Visual Assist zur Verfügung steht nehm ich für großräumige Suchen (Projekt, Projektmappe, Verzeichnis) am liebsten die In-Datei-Suchen-Funktion. Die ist normalerweise schneller. Bisher war ich damit auch ganz zufrieden. Zumindest kamen mir trotz quasi täglicher Nutzung in VS2008 bisher keine der genannten Probleme unter. Das einzige was ich ein bisschen seltsam finde: Ist eine Datei mehrfach in einer Projektmappe eingebunden, so werden die Funde in dieser Datei auch mehrfach gemeldet... aber da das eher selten der Fall ist kann ich damit leben.

Kaum zwei Wochen auf tumblr gebloggt, und schon wird es von Yahoo gekauft.

Yahoo ist der größte Datenvernichter der Menschheitsgeschichte. Jason Scott nennt sie yahoo!locaust – sie kaufen Dienste mit enormem Maß an Kreativität und Benutzerinhalt für viele Milliarden; lassen sie ein Jahr verrotten; und löschen dann alles.

Kann mir jemand eine Plattform empfehlen, die tumblr ähnlich ist? Also, Videos via Drag'n'Drop posten statt in irgendwelchen Tags rumzuwühlen und so? Ich hatte von Anfang an an soup.io gedacht, aber scheinbar sind deren Wartung und Entwicklung quasi nicht existent.

Keine Ahnung ob das gut ist, aber in letzter Zeit ist mir http://pinterest.com/ öfter mal über den weg gelaufen. Finde die landing page irgendwie unsympathisch...

Mmh Yahoo( Japan) ist in Japan populärer als Google, bei denen läuft es recht gut, vielleicht schaut sich ja Yahoo Inc mal was beim besser laufenden Kompagnon ab :).

hagbard hat geschrieben:Ich hab die Erfahrung gemacht, dass FindInFiles in VS generell (beobachtet bei 2005 und 2008) nicht sonderlich zuverlässig funktioniert und nutze für grössere Suchen eher einen passablen Editior wie Notepad++ :x Bisher dachte ich nur ich bediene das Ding falsch aber ich scheine ja nicht der einzige mit Problemen zu sein.

Ach, Find In ... funktioniert in Eclipse/CDT auch nicht :lol:

glassbear hat geschrieben:

hagbard hat geschrieben:Ich hab die Erfahrung gemacht, dass FindInFiles in VS generell (beobachtet bei 2005 und 2008) nicht sonderlich zuverlässig funktioniert und nutze für grössere Suchen eher einen passablen Editior wie Notepad++ :x Bisher dachte ich nur ich bediene das Ding falsch aber ich scheine ja nicht der einzige mit Problemen zu sein.

Ach, Find In ... funktioniert in Eclipse/CDT auch nicht :lol:

Dazu gibt es ja auch grep ;)

antisteo hat geschrieben:Dazu gibt es ja auch grep ;)

Exakt, oder um es auf Code zu beschränken und schneller zu machen: cgvg.

grep findet aber keine Strings die sich in ungespeicherten Änderungen befinden, die kennt nämlich nur der Editor in denen sie gemacht wurden.

Dann speicher halt? Wie viele Dateien muss man denn ungespeichert offen haben? Kann mir da ehrlich gesagt keinen sinnvollen Anwendungsfall für vorstellen...

Also bei Eclipse/Java funktionier "Search/File..." einwandfrei inkl. nicht gespeicherter Änderungen. "References" finden funktioniert natürlich ebenso gut (inkl. eingebundnener Bibliotheken, was ein deutlicher Vorteil gegenüber meinem Liebling NetBeans ist).

Florian Keßeler hat geschrieben:Dann speicher halt? Wie viele Dateien muss man denn ungespeichert offen haben? Kann mir da ehrlich gesagt keinen sinnvollen Anwendungsfall für vorstellen...

Deine Vorstellungskraft könnte besser sein ;) Ich wollte nur auf diesen Unterschied zwischen einem externen Tool wie grep und der eingebauten "in allen Dateien suchen"-Funktion aufmerksam machen. Es gibt sicherlich Situationen in denen ein "Dann speicher halt" nicht alle glücklich macht.

Sternmull hat geschrieben:

Florian Keßeler hat geschrieben:Dann speicher halt? Wie viele Dateien muss man denn ungespeichert offen haben? Kann mir da ehrlich gesagt keinen sinnvollen Anwendungsfall für vorstellen...

Deine Vorstellungskraft könnte besser sein ;) Ich wollte nur auf diesen Unterschied zwischen einem externen Tool wie grep und der eingebauten "in allen Dateien suchen"-Funktion aufmerksam machen. Es gibt sicherlich Situationen in denen ein "Dann speicher halt" nicht alle glücklich macht.

Du kannst ja zur Not ein Versionskontrollsystem benutzen, falls du alte Versionen des Codes nicht überspeichern willst

Chromanoid hat geschrieben:Also bei Eclipse/Java funktionier "Search/File..." einwandfrei inkl. nicht gespeicherter Änderungen. "References" finden funktioniert natürlich ebenso gut (inkl. eingebundnener Bibliotheken, was ein deutlicher Vorteil gegenüber meinem Liebling NetBeans ist).

Bei Java ist Eclipse wesentlich besser. In CDT funktioniert hier in 2/3 der Faelle nicht mal der Debugger... Also, er funktioniert schon, nur Breakpoints werden nicht getriggert, die Haelfte im Variables View fehlt (und man kann nix hinzufuegen), etc.

Ein Hoch auf freie Auswahl :(

antisteo hat geschrieben:Du kannst ja zur Not ein Versionskontrollsystem benutzen, falls du alte Versionen des Codes nicht überspeichern willst

Mach ich auch grundsätzlich, deshalb ist mir persönlich das Feature auch fast schon egal. Aber ich finde es nicht verkehrt wenn eine Volltextsuche wirklich in dem sucht was ich grad bearbeite, egal ob gespeichert oder nicht. Das heißt aber nicht das ich es toll finden würde wenn mir jemand vorschreibt generell speichern zu müssen bevor ich die Suche ausführen darf (betrifft ja auch gefundene Positionen die durch Änderungen verschoben wurden). Je mehr man beachten muss, desto mehr Chancen gibt es etwas falsch zu machen. In diesem Fall wäre das wahrscheinlich nicht grundsätzlich tödlich... aber es geht mir auch ein bisschen ums Prinzip: Warum sollte ich mich mit Extra-Schritten plagen wenn man mir die abnehmen kann. Es gibt in der Softwareentwicklung nun wirklich schon genug Mist den man falsch machen kann und auch macht. Jeder Stein der von vornehherein aus dem Weg geräumt wird ebnet den Weg. Auch wenn es in diesem Fall nur ein Kiesel ist.

glassbear hat geschrieben:

Chromanoid hat geschrieben:Also bei Eclipse/Java funktionier "Search/File..." einwandfrei inkl. nicht gespeicherter Änderungen. "References" finden funktioniert natürlich ebenso gut (inkl. eingebundnener Bibliotheken, was ein deutlicher Vorteil gegenüber meinem Liebling NetBeans ist).

Bei Java ist Eclipse wesentlich besser. In CDT funktioniert hier in 2/3 der Faelle nicht mal der Debugger... Also, er funktioniert schon, nur Breakpoints werden nicht getriggert, die Haelfte im Variables View fehlt (und man kann nix hinzufuegen), etc.

Ein Hoch auf freie Auswahl :(

Hast Du mal Netbeans (für C++) ausprobiert? Mich würden da die Unterschiede interessieren...

Ich reviewe gerade eine umfangreiche Menge Code eines relativ neuen Kollegen und bin mal wieder kurz davor, anzufangen ein Tool wie StyleCop für C++ zu schreiben.

Locker 200-300 neue Klassen, die den Weg in mein Projekt finden sollen und praktisch jede hat ihr eigenen Namensschema, für was sie nun camelCase, wofür PascalCase oder auch std_lib_style, ob und für was sie Prefixes einsetzt, aber alle Stylechecktools für C++ scheinen sich auf Indentation, Alignment, Padding und Formatting zu beschränken (http://www.suodenjoki.dk/us/archive/201 ... kstyle.htm).

Mal sehen, ob dieses mal meine Verzweiflung groß genug ist, um mich ernsthaft an ein solches Projekt zu machen.
Ein Open Source C++ Parser mit vollständigem Sprachumfang und und ohne große Abhängigkeiten sollte doch zu finden sein.

Chromanoid hat geschrieben:Hast Du mal Netbeans (für C++) ausprobiert? Mich würden da die Unterschiede interessieren...

Ja. Netbeans war wesentlich angenehmer zu nutzen fuer C/C++ und hat auch wesentlich besser funktioniert.
Das Problem ist hier, dass unsere Software in Eclipse integriert ist und der C++-Code als Plugin ausgefuehrt wird. Die umfangreiche Ausfuehrungsumgebung ist in Eclipse integriert. Ich kann zwar von aussen gdb auf den Plugin Executor attachen (was eine Formulierung...), dann fehlen mir aber die ganzen zusaetzlichen Sachen aus unserer Umgebung, die ich zum Debuggen brauche :(
Kompliziert. Mittlerweile machen wir groesstenteils printf()-Debugging, weils einfach "schneller" geht als mit CDT. Leider will uns Rogue Software keine Totalview-Lizenz verkaufen, warum auch immer :?:
Da die CDT-Code Indizierung manchmal unzuverlaessig arbeitet, bin ich mittlerweile auf vim+clang plugin umgestiegen. Beides selbst kompiliert im $HOME-Verzeichnis liegen, da Red Hat 5.8 etwas alt ist. CDT erkennt wenigstens meistens das die Code Files von ausserhalb geaendert wurden, so dass ich CDT nur noch fuer den Build benutze.

Immer dran denken: Performance ist egal. Stabilitaet >> Anwender/Entwickler Tools >> Execution Performance. Auch wenn 1s laengere Execution Performance mal eben $1-10 Mio kosten kann :o

Edit: Wenn Sublime auf Red Hat 5.8 laufen wuerde, wuerde ich das nehmen. Go To Anything ist absolut super! Egal ob zum Benutzen des OS oder zum Arbeiten :mrgreen:


Genug gejammert, zurueck zum Debuggen: Warum sind meine Noise-Werte besser als erwartet? :?:

@kaiserludi: Fuer den google C++ Style Guide gibt es ein beigelegtes Skript, mit dem man pruefen kann, ob sich der Code an den Style Guide haelt. Falls der Style Guide nicht passt, laesst sich auch schnell was mit clang zusammenbauen.

@glassbear:
Danke, schau ich mir mal an.

Meine Webseite sieht im IE6, IE7 und IE8 scheiße aus.
Erst ab IE9 wird HTML und CSS unterstützt.

antisteo hat geschrieben:Meine Webseite sieht im IE6, IE7 und IE8 scheiße aus.
Erst ab IE9 wird HTML und CSS unterstützt.

Wie ich schonmal an anderer Stelle erwähnte sieht sie im Firefox meiner bescheidenen Meinung nach ebenfalls nicht gut aus. Also falls dich das tröstet.

movss xmm0,dword ptr [rbx+8]
movss xmm1,dword ptr [rbx+0Ch]
movss xmm2,dword ptr [rbx+2Ch]
mov r8,rcx
lea rdx,[rbp-70h]
lea rcx,[rbp-10h]
addss xmm2,dword ptr [r13]
movss dword ptr [rsp+30h],xmm0
movss xmm0,dword ptr [rbx+10h]
mov eax,dword ptr [rsp+30h]
mov dword ptr [rbp-70h],eax
movss dword ptr [rsp+38h],xmm0
movss xmm0,dword ptr [rbx+14h]
movss dword ptr [rsp+34h],xmm1
mov eax,dword ptr [rsp+34h]
mov dword ptr [rbp-6Ch],eax
mov eax,dword ptr [rsp+38h]
mov dword ptr [rbp-68h],eax
movss xmm1,dword ptr [rbx+18h]
movss dword ptr [rsp+3Ch],xmm0
movss xmm0,dword ptr [rbx+1Ch]
mov eax,dword ptr [rsp+3Ch]
mov dword ptr [rbp-64h],eax
movss dword ptr [rsp+44h],xmm0
movss xmm0,dword ptr [rbx+20h]
movss dword ptr [rsp+40h],xmm1
mov eax,dword ptr [rsp+40h]
mov dword ptr [rbp-60h],eax
mov eax,dword ptr [rsp+44h]
movss xmm1,dword ptr [rbx+24h]
movss dword ptr [rsp+48h],xmm0
movss xmm0,dword ptr [rbx+28h]
mov dword ptr [rbp-5Ch],eax
mov eax,dword ptr [rsp+48h]
movss dword ptr [rsp+4Ch],xmm1
movss xmm1,dword ptr [rbx+30h]
movss dword ptr [rsp+50h],xmm0
mov dword ptr [rbp-58h],eax
mov eax,dword ptr [rsp+4Ch]
addss xmm1,dword ptr [r13+4]
movss xmm0,dword ptr [rbx+34h]
movss dword ptr [rsp+54h],xmm2
mov dword ptr [rbp-54h],eax
mov eax,dword ptr [rsp+50h]
mov dword ptr [rbp-50h],eax
mov eax,dword ptr [rsp+54h]
addss xmm0,dword ptr [r13+8]
movss dword ptr [rsp+58h],xmm1
mov dword ptr [rbp-4Ch],eax
mov eax,dword ptr [rsp+58h]
movss dword ptr [rsp+5Ch],xmm0
mov dword ptr [rbp-48h],eax
mov eax,dword ptr [rsp+5Ch]
mov dword ptr [rbp-44h],eax
call Math::operator+<float> (0140013920h)
mov rcx,qword ptr [rax]
xorps xmm6,xmm6
mov qword ptr [rbp-40h],rcx
mov rcx,qword ptr [rax+8]
mov qword ptr [rbp-38h],rcx
mov rcx,qword ptr [rax+10h]
mov qword ptr [rbp-30h],rcx
mov rcx,qword ptr [rax+18h]
mov qword ptr [rbp-28h],rcx
mov rcx,qword ptr [rax+20h]
mov rax,qword ptr [rax+28h]
mov qword ptr [rbp-18h],rax
mov qword ptr [rbp-20h],rcx

Wisst ihr, was der Code macht? Ratet mal!

Der addiert drei Zahlen zu einer Matrix und ruft dann den Verknüpfungsoperator mit einer anderen Matrix auf.

Die 60 mov-Befehle die ihr da seht? Die sind für nichts da. Die schieben die Matrix zu einer Adresse zur anderen, um am Ende wieder in den Anfang zu schreiben. Der komplette Block sollte nur aus

addss xmm2,dword ptr [r13]
addss xmm1,dword ptr [r13+4]
addss xmm0,dword ptr [r13+8]
lea rdx,[rbp-70h]
lea rcx,[rbp-10h]
call Math::operator+<float> (0140013920h)

bestehen. Alles andere ist nutzlos. Und wenn ich von Hand inline, kommen auch exakt diese Befehle raus.

Und dann denken die Leute, es spräche für Java oder für C#, dass die fast an der Performance von C++ dran sind. Als wäre das was Positives! Nein, C++ ist einfach so arschlahm dass es keinen Unterschied macht weil die CPU ja sowieso den halben Nachmittag in load-hit-stores feststeckt!

Krishty hat geschrieben:Alles andere ist nutzlos. Und wenn ich von Hand inline, kommen auch exakt diese Befehle raus.

Wieso kommt beim Hand-Inlining etwas anderes heraus als beim Maschinen-Inlining? Irgendwas machst du falsch - oder du benutzt den falschen Compiler.
Und die Benchmarks C++ gegen Java werden übrigens meist mit dem gcc gemacht, nicht mit deinem Visual-Teil.

antisteo hat geschrieben:Wieso kommt beim Hand-Inlining etwas anderes heraus als beim Maschinen-Inlining? Irgendwas machst du falsch - oder du benutzt den falschen Compiler.

Weil da nicht 30 Jahre lang Informatikprofessoren am Compiler geschraubt haben, sondern komplexitätsbewusste Existenzen wie ich, die Fehler nur beheben, wenn sie sie vollständig begriffen haben. Zum Glück keine ahnungslosen Klugscheißer, die meinen, jeder könnte sich mal schnell da dransetzen und Register Coloring revolutionieren weil ihm ein paar Kompilate nicht passen – das war ja schon bei GCC so fick-fack-fantastisch, als ein Hobby-Mensch die Aliasing Analysis verfasst hat um seinen Code schneller zu machen und sie erst fünf Jahre später durch subtile Fehler bemerkt haben, dass sie die wegschmeißen können :)

Jetzt lass mich hier weiterhin alle Interessierten daran erinnern was passiert, wenn man bestimmte bekannte Eigenheiten nicht beachtet, bis die Leute, die was davon verstehen und dafür zuständig sind, eine Lösung liefern, damit die nächste Visual Studio-Version wieder 15 % schnelleren Maschinentext erzeugt statt bei euch Herzinfarkte auszulösen weil euer Weltbild vom alles richtenden Compiler zusammenbricht sobald ihr ins Kompilat guckt.

Mit LLVM-IR wäre das nicht passiert.
(bzw zum Jammern: der Chinese in unserem LLVM-Projekt an der Uni kopiert einfach nur den Beispielcode in seinen Code rein und committet das)

antisteo hat geschrieben:Mit LLVM-IR wäre das nicht passiert.

Was? Visual C++’ schlechte Kopien, GCCs kaputte Aliasing-Analyse, oder die chinesischen Plagiate in eurem LLVM?

GRAAAH. Diese verdammte Baufirma hat soeben zum dritten Mal seit Bestehen der Monster-Baustelle das Wasser abgedreht, ohne vorher Bescheid zu sagen. Sind die nicht verpflichtet, irgendeinen Aushang in jedem Haus zu machen? Das geht mir barbarisch auf den Zeiger.

Und nein, es hat NICHTS mit Kaffeemangel zu tun, unter dem ich jetzt natürlich auch leide.

Krishty hat geschrieben:

antisteo hat geschrieben:Mit LLVM-IR wäre das nicht passiert.

Was? Visual C++’ schlechte Kopien, GCCs kaputte Aliasing-Analyse, oder die chinesischen Plagiate in eurem LLVM?

Nein.
Die erste Zeile meines Kommentars war wieder eine meiner Standardantworten auf dein Gejammere.

antisteo hat geschrieben:Die erste Zeile meines Kommentars war wieder eine meiner Standardantworten auf dein Gejammere.

Wenn Du jetzt schon selbst begriffen hast, dass Du nichts Hilfreiches oder auch nur Neues beitragen kannst, dann lass doch bitte den Kommentar gleich ganz weg. Betrachte das als offizielle Warnung. Ich hatte Dich schonmal gesperrt, und habe auch keine Probleme, das wieder zu tun. In Anbetracht Deiner bisherigen Beitrage ginge da nichts verloren, was für dieses Forum von Wert wäre.

Schrompf hat geschrieben:

antisteo hat geschrieben:Die erste Zeile meines Kommentars war wieder eine meiner Standardantworten auf dein Gejammere.

Wenn Du jetzt schon selbst begriffen hast, dass Du nichts Hilfreiches oder auch nur Neues beitragen kannst, dann lass doch bitte den Kommentar gleich ganz weg. Betrachte das als offizielle Warnung. Ich hatte Dich schonmal gesperrt, und habe auch keine Probleme, das wieder zu tun. In Anbetracht Deiner bisherigen Beitrage ginge da nichts verloren, was für dieses Forum von Wert wäre.

Ich wüsste auch nicht, welchen Nutzen ich aus Rumgejammere ziehen könnte, wenn derjenige, der jammert, niemals eine Lösung für sein Problem ausprobieren wird. Sperre mich ruhig, das zeigt vor allem deine Stärke als Moderator.

Schrompf hat geschrieben:

antisteo hat geschrieben:Die erste Zeile meines Kommentars war wieder eine meiner Standardantworten auf dein Gejammere.

Wenn Du jetzt schon selbst begriffen hast, dass Du nichts Hilfreiches oder auch nur Neues beitragen kannst, dann lass doch bitte den Kommentar gleich ganz weg. Betrachte das als offizielle Warnung. Ich hatte Dich schonmal gesperrt, und habe auch keine Probleme, das wieder zu tun. In Anbetracht Deiner bisherigen Beitrage ginge da nichts verloren, was für dieses Forum von Wert wäre.

Jammern über Jammer, also quasi Metagejammer, ist nun verboten? Okay … !?