Benutzt ihr Code-Outlining?



  • Umfrage: Benutzt ihr Code Outlining

    Auswahl Stimmen Prozent
    Ja 10 26.3%
    Nein 28 73.7%

    Inzwischen bieten ja viele IDEs Code Outlining an. Das bedeutet, dass man bestimmte Teile des Codes (z.B. einen Block, eine Funktion) ausblenden kann, oft mit einem '-' am linken Rand.
    Mich würde mal interressieren, wer das in der Praxis nutzt. Die an sich gute Idee bringt mir persönlich leider gar nichts, weil ich immer recht kleine Funktionen hab, fast nie mehr als 2fach geschachtelte Schleifen und deshalb keinen großen Nutzen davon hab.

    Achtung: Die Frage ist nicht, wer es angeschaltet hat, sondern wer es wirklich immer wieder mal benutzt.



  • Wenn ich wüsste wie das beim Emacs geht, würde ich es machen 🙂

    So aber "nein"!



  • Optimizer schrieb:

    Inzwischen bieten ja viele IDEs Code Outlining an.

    "Code Outlining"? Die einzigen die das so nennen sind Microsoftler. Ursprünglich heißt es "Code Folding".
    Aber wenn es MS auch einfach so genannt hätte könnte man ja denke sie hätten es nicht erfunden 😉

    Aber so weiß man wenigsten anhand deiner Wortwahl was für'ne IDE du benutzt...da hab ich dich erwischt du Strolch 😃

    bis dänn, O'Dog

    P.S. Nee, benutze es net



  • kingruedi schrieb:

    Wenn ich wüsste wie das beim Emacs geht, würde ich es machen

    hideshow.el, folding-mode, outline-mode... Ich hab das aber noch nie gebraucht.



  • Finde das nicht so sinnvoll, normal hab ich nicht so riesen Methoden, dass es von Nutzen wäre!



  • nutze es manchmal, für Klassendefinitonen..



  • weiß nicht.

    ich hab es neulich mal intensiv benutzt. am ende jeder zeile, die ne öffnende geschweifte klammer hat, sogar noch mit // nen kommentar rein, der den block kurz sinnvoll benennt. ich konnte ganz nach lust und laune einklappen und ausklappen und so die sache mal mehr im detail oder mehr in der übersicht sehen.
    das erinnerte schon ans literate rogramming von don knuth (hab ich mich seine mmix-ware als buch gekauft und gelesen).

    mann, dabei kam vielleicht ne kacke raus! hier ne etwas spätere version, als ich bereits setWarrior() aus fight() herausgelöst hatte.

    übrigens ist knuths code auch undebuggbar, wie ich feststellen mußte, als ich rausfinden wollte, wo mein mmix-code im interpreter ne schutzverletzung erzeugt.

    class Battlefield{
    private:
    	Field field[SIZEY][SIZEX];
    	int population[10];
    private:
    	void setTopology(){
    		for(int y=0;y!=SIZEY;++y)
    			for(int x=0;x!=SIZEX;++x)
    				for(int i=0;i!=8;++i)
    					field[y][x].link[i]=&field[(y+dirToY[i]+SIZEY)%SIZEY][(x+dirToX[i]+SIZEX)%SIZEX];
    	}
    public:	
    	Battlefield(){
    		setTopology();
    	}
    	void clear(bool show){
    		population[0]=SIZEX*SIZEY;
    		for(int i=1;i<10;++i)
    			population[i]=0;
    		if(show){
    			colcout.setcolor(colors[0]);
    		}
    		for(int y=0;y!=SIZEY;++y){
    			for(int x=0;x!=SIZEX;++x){
    				field[y][x].warrior=0;
    				field[y][x].comvar=0;
    				for(int i=0;i!=10;++i)
    					field[y][x].bullets[i]=0;
    				if(show){
    					colcout.gotoxy(x+1,y+1);
    					colcout<<" "<<flush;
    				}
    			}
    		}
    	}
    	void setWarrior(int y,int x,int warrior,bool show){
    		Field& f=field[y][x];
    		if(warrior==f.warrior)
    			return;
    		--population[f.warrior];
    		field[y][x].warrior=warrior;
    		++population[f.warrior];
    		if(show){
    			colcout.gotoxy(x+1,y+1);
    			colcout.setcolor(colors[warrior]);
    			colcout<<" "<<flush;
    		}
    	}
    	int fight(Warrior* warrior1,Warrior* warrior2,bool show){
    		clear(show);
    		setWarrior(rand()%10,rand()%10,1,show);
    		setWarrior(rand()%10,rand()%10,2,show);
    		for(int round=0;round<500;++round){
    //			if(show)	Sleep(1000);
    			for(int y=0;y!=SIZEY;++y){
    				for(int x=0;x!=SIZEX;++x){
    					Field& f=field[y][x];
    					int my_warrior=f.warrior;
    					int neighbor_comvar[8];
    					int neighbor[8];
    					for(int i=0;i!=8;++i){
    						neighbor_comvar[i]=f.link[i]->comvar;
    						neighbor[i]=f.link[i]->warrior;
    					}
    					int bullet_array[8]={};
    					switch(f.warrior){
    					case 1:
    						f.result=warrior1->move(my_warrior,f.comvar,neighbor_comvar,neighbor,bullet_array);
    						break;
    					case 2:
    						f.result=warrior2->move(my_warrior,f.comvar,neighbor_comvar,neighbor,bullet_array);
    						break;
    					}
    					for(int i=0;i!=8;++i){
    						f.link[i]->bullets[my_warrior]+=bullet_array[i];
    					}
    				}
    			}
    			for(int y=0;y!=SIZEY;++y){
    				for(int x=0;x!=SIZEX;++x){
    					Field& f=field[y][x];
    					f.comvar=f.result;
    					int firstwinner=0;
    					int lastwinner=0;
    					int maxbullets=f.bullets[0];
    					int totalbullets=f.bullets[0];
    					for(int i=1;i<10;++i){
    						int bullets=f.bullets[i];
    						if(bullets>=maxbullets){
    							lastwinner=i;
    							if(bullets>maxbullets){
    								firstwinner=i;
    								maxbullets=bullets;
    							}
    						}
    						totalbullets+=bullets;
    						f.bullets[i]=0;
    					}
    					if(totalbullets>=3 && firstwinner==lastwinner){
    						setWarrior(y,x,firstwinner,show);
    					}
    
    				}
    			}
    			for(int i=0;i!=10;++i){
    				if(population[i]==SIZEX*SIZEY){
    					if(i==1)
    						return population[1]*500*10-round*(SIZEX*SIZEY);
    					else
    						return population[1]*500*10+round*(SIZEX*SIZEY);
    				}
    			}
    		}
    		return population[1]*500*10-500*(SIZEX*SIZEY);;
    	}
    };
    

    mein urteil bisher: code folding ist für C gut und führt zu C-code.

    werde aber dranbleiben. die ide, die ich jetzt benutze, kann das ja und ich werde immer wieder mal folden, wenn es sein muß. und vor allem werde ich schauen, um es wieder sein muß. es könnte auch sein, daß ich immer statt zu folden den code verbessern sollte.



  • Ich hab's mir immer wahnsinnig praktisch vorgestellt, bis ich es dann hatte. Die geistige Belastung geht durch ein Einklappen nicht wesentlich runter, da teile ich meinen Code doch lieber in kleinere Funktionen und viele Dateien auf.



  • Bei C# ist es Gold wert.
    Denn der Designer erstellt massig Code - der wird dann immer weggeklappt und ich bin glücklich (zumal die IDE es automatisch wegmacht).

    Bei C++ verwende ich es aber fast nie, dito bei PHP.

    Einzig wo ich es sinnvoll verwende: ich habe eine Datei algorithm.hpp wo einige algos drinnen sind, die der C++ Standard Library fehlen. Das sind halt viele algos - und jeder halt 6-7 Zeilen lang (vorallem das conecpt checking kostet immer mehrere Zeilen). Alles in allem ist so eine Funktion also 'relativ' lang. Und da ich alle algos in dieser Datei habe (für eine Trennung bin ich zufaul) ist das Outliniing ganz praktisch.



  • Shade Of Mine schrieb:

    Einzig wo ich es sinnvoll verwende: ich habe eine Datei algorithm.hpp wo einige algos drinnen sind, die der C++ Standard Library fehlen. Das sind halt viele algos - und jeder halt 6-7 Zeilen lang (vorallem das conecpt checking kostet immer mehrere Zeilen). Alles in allem ist so eine Funktion also 'relativ' lang. Und da ich alle algos in dieser Datei habe (für eine Trennung bin ich zufaul) ist das Outliniing ganz praktisch.

    Warum? Wenn du alle methoden zugeklappt hast, dann sieht dein datei genauso aus wie in ein normale outline- sprich klassenbaum-ansicht wo man ja auch alle methoden sieht. Sehe den mehrwert hier nicht.



  • Jain...

    Meine IDE zeigt beim Klick auf eine Member-Funktion auch nur diese Funktion und nichts anderes im Editor an. Richtiges Folding kann die aber nicht (Also einklappen bei Klammern). Also ist meine Antwort wohl... Ein bischen 🙂



  • O'Dog schrieb:

    Warum? Wenn du alle methoden zugeklappt hast, dann sieht dein datei genauso aus wie in ein normale outline- sprich klassenbaum-ansicht wo man ja auch alle methoden sieht. Sehe den mehrwert hier nicht.

    Ich finde es ist etwas übersichtlicher - weil ich eben nur den relevanten Code sehe und der nicht relevante ist garnicht vorhanden. Natürlich ist das kein wirklich großer Vorteil, aber ich finde es eine Spur praktischer.



  • Jetzt ist mir doch noch eine Anwendung eingefallen: Wenn ich eine Klassendefinition anschaue und in der Klasse nochmal andere Klassen (oder enums) geschachtelt habe, blende ich die aus. Super, nicht wahr? 👍 🙂
    Und das mit dem GUI-Designer bei C# stimmt natürlich auch.



  • Ich habe es ab und an schonmal verwendet, aber eigentlich Scrolle ich lieber oder
    benutze einfach den Klassenbaum um direkt dorthinzuspringen.



  • Ich hätte es gerne bei VC6. Bei nem anderen Editor habe ich es und nutze es begeistert!



  • estartu_de schrieb:

    Ich hätte es gerne bei VC6. Bei nem anderen Editor habe ich es und nutze es begeistert!

    Guck mal ob das Visual Assist kann. (Weiß nicht ob das umsonst ist)
    PS: Ich benutze kein Code-Outlining. (Stört mich teilweise sogar)


Anmelden zum Antworten