Archiv verlassen und diese Seite im Standarddesign anzeigen : NetBeans oder Eclipse
Hallo zusammen,
ich möchte wieder mehr mit Java machen, und tue mich schwer, zu entscheiden, welche Entwicklugsumgebung ich einsetzen soll.
Eclipse oder NetBeans?
Was ich neben Java noch programmiere ist Java Script und PHP.
Ich habe schon gegoogelt und die IDE's sehen super aus und haben sicherlich jede für sich Vorteile, aber ich kann mich nicht entscheiden und hoffe auf eure Tipps.
Einen schönen 1. Advent,
viele Grüße,
jor
Also ich benutze zum Programmieren am liebsten nen Texteditor - Scite beispielsweise ;)
MfG Bischi
Hi Bischi,
hhmm, Hardcore-Proggen, naja, etwas mehr Luxus wünsche ich mir dann doch...;) Eigentlich gefällt es mir schon, dass ich nicht mehr nur mit einem Editor coden muss, man hat zwar nicht mehr alles in der Hand, aber es ist
m. E. schneller und ... angenehmer. :)
mehlvogel
02-12-2007, 12:48
Naja das ist eine Frage des persönlichen Geschmacks. Schau dir beide IDEs an und entscheide selbst. Ich habe mich für Eclipse entschieden, kenne Netbeans aber nur sehr sehr rudimentär, so dass ich einen stärkeres Kriterium als "persönliche Präferenz" nicht angeben kann.
hi mehlvogel,
bei mir sieht es ähnlich aus wie bei dir, nur dass ich von der netbeans-seite auf eclipse schaue. kann es sein, dass eclipse hier in deutschland eine gößere lobby hat, und netbeans eher im ausland?
ich werde mir eclpise dann mal installieren und schaue es mir an.
@all: Vielen Dank für eure Antworten!
Was ich neben Java noch programmiere ist Java Script und PHP.
Tja, ich bin schon so alt und klapperig, dass ich alle 3 Sprachen nur mit Texteditoren programmiere. Da weiss man wenigstens, was abläuft. Zudem muss man sich nicht jedes Jahr in eine neue IDE einarbeiten. :rolleyes:
Die einzige IDE, die ich wirklich schätze, ist die sun-j2me für Handys.
so long,
BlueJay
Editor coden muss, man hat zwar nicht mehr alles in der Hand, aber es ist
m. E. schneller und ... angenehmer. :)
Hm, schneller und angenehmer? Das bin ich eindeutig mit einem Texteditor meiner Wahl und CommandLine-Tools.
Habe 2-3x Klicki-Bunti-IDEs probiert, bei Qt merkte ich bald, dass die Hauptlast trotzdem auf dem Editor lag. Und mein Entsetzen wurde groß, als ich die Buttons und Menupunkte mal umsortieren wollte, als es zu viele wurden! (diskontinuierliche Indices oder Indices kreuz und quer statt geometrisch-logisch verteilt!)
Bei Javascript und php gab es einfach nix, und bevor ich durch Eclipse oder Netbeans durchgestiegen bin, war ich "zu Fuß" schneller.
Gut finde ich das Sun J2ME, die haben sich auch nur darauf beschränkt, CommandLine Tools (und den Handy-Emulator) in Menuitems zu stecken und den Compiler/Linkeroutput in ein Textfenster zu pappen, der Rest geht wieder mit einem Editor deiner Wahl.
so long,
BlueJay
Hallo BlueJay,
hhmm, hört sich für mich dann doch nach einem Editor-Proggen an ;-)
Aber wie kommst du mit der Syntax bzw. deren Fehlern klar, ist da der
Suchaufwand nicht sehr groß? Ich würde mir gerne mal deine Entwicklungsumgebung anschauen... Was du mit "CommandLine Tools"
meinst weis ich nicht 100%ig, aber es macht mich sehr neugierig.
Wenn man natürlich in der Lage ist Handler und Co. selbst anzulöten, dann hat man die Applikation sicherlich besser im Griff.
Ich werde mal ein bißchen googeln müssen... *lol*
Danke!
Zum Editieren benutze ich den Internal Editor vom Krusader.
Das Schätzchen erkennt an den Endungen, was ich gerade proggen will.
Es gibt Zeilennumerierung, es gibt Klammerhilighting und -Ein/Ausblenden, der erkennt Funktionen und etliche Syntaxen sowie alle nötigen Codepages.
Die Dreckfehler, die du fabrizierst, sind da schnell gefunden.
Command line Tools sind javac, java, gcc mit qmake und make und Konsorten
so long,
BlueJay
Heute habe ich gesehen, dass es bei Sun auch ein Paket gibt, JDK mit Command Line Tools, ich werde es mir mal anschauen.
HHhhmm eigentlich dann auch der richtige Druck wieder ein Linux zu installieren, du weist ja wie das ist, man hat viel Wünsche, aber wenig Zeit.
Aber ich habe ja bald Urlaub, da kann ich bestimmt was stemmen :) :)
Danke für deine Infos!!!
Zum Editieren benutze ich den Internal Editor vom Krusader.
Das Schätzchen erkennt an den Endungen, was ich gerade proggen will.
Es gibt Zeilennumerierung, es gibt Klammerhilighting und -Ein/Ausblenden, der erkennt Funktionen und etliche Syntaxen sowie alle nötigen Codepages...
Bietet Dir Deine IDE Autocompletion von Klassen und Methoden (inkl. der Anzeige der geforderten Parameter und ihrer Typen sowie des Rückgabetyps), automatischen Import (oder arbeitest Du mit "import java.xyx.*;"?), Umbenennen von Packages, Klassen, Methoden (inkl. aller Referenzen), Einbinden von CVS/SVN, automatisches Generieren von Gettern/Settern, Rebuild-On-Change (verbunden mit der sofortigen Anzeige aller Fehler, Warnungen, nicht initialisierter Variablen, ...), komfortables Erstellen von Packages, Klassen, JAR/WAR/EAR, Verschieben von Methoden / Klassen in andere Klassen / Packages mit automatischer Anpassung aller Dateien, in denen diese rerefenziert werden? Verhindert sie z. B. nicht-statische Methoden in Interfaces? Haut sie Dir auf die Finger, wenn Du in statischen Methoden Objektvariablen benutzen willst? Siehst Du bei ihr auf einem Blick, welche Packages / Klassen / Methoden in Deinem Projekt in welcher Zeile fehlerhaft sind?
Bietet Dir Dein Editor bequeme Unterstützung beim Erstellen und Generieren von Javadoc? Kann er automatisch Code formatieren, Code-Blöcke auskommentieren, Code ergänzen, kannst Du Dir von ihm auf Tastendruck in Frage kommende Variablen- oder Methoden-Namen zur Auswahl anbieten lassen? Verwarnt er Dich, wenn Du z. B. in Java5 Collections nicht typisierst oder in Java4 Typecasts vergisst? Mault er rum, wenn Du in einer Java4-Umgebung Java5-Syntax benutzt? Nimmt er die benötigten Imports mit, wenn Du eine Methode oder auch nur ein paar Codezeilen aus Projekt A, Package B, Klasse C, Methode D per Copy&Paste in Projekt W, Package X, Klasse Y, Methode Z kopierst? Zeigt er Dir an, wenn Du als "veraltet" gekennzeichnete Klassen oder Methoden benutzt? Kannst Du Methoden / Klassen als veraltet markieren und siehst dann auf einen Blick, wo sie noch benutzt werden?
Ist in Deiner IDE ein Debugger integriert? Kannst Du auf Tastendruck für jede Methode (sofern der Java-Code vorliegt) zu ihrer Definition springen oder zu einer Methode sämtliche Stellen anzeigen lassen, an denen sie benutzt wird? Kannst Du Abhängigkeiten von anderen Projekten definieren, um bei Änderungen in Basisprojekten sofort die rote Lampe in den abhängigen Projekten angehen zu lassen, wenn Du inkompatible Änderungen einbaust?
Wie viele Sekunden brauchst Du, um ein Package oder eine Klasse zu kopieren (inkl. Umbenennen)? Wie unterstützt Dich Deine IDE, wenn es um die Syntaxprüfung von XML-Konfigs oder Propertydateien geht? Wie viele Tastaturanschläge bzw. Mausklicks brauchst Du, um eine Änderung testen zu können?
Ich habe meine Java-"Karriere" mit SCiTE begonnen, habe irgendwann mit Eclipse (IIRC Version 2.3) angefangen und würde selbst bei Strafe des Erschießens nicht mehr davon ablassen. Die Produktivität (sprich die Quantität und Qualität des erzeugten Codes, die fast automatisch erzeugte Dokumentation, die Möglichkeiten zum Refactoring, Testen, Debuggen, Deployment) ist für mich mit Eclipse um etliche Größenordnungen höher als mit SCiTE & Co. Ich bin oft in der Situation, dass ich unter erheblichem Zeitdruck arbeiten muss - ohne eine komfortable IDE wie Eclipse wäre das nicht drin.
Jan
Hallo jan61,
das sind natürlich Argumente! Da ich mir unter Commans Line Tools nicht viel vortellen konnte, geschweige denn anwenden, sehe ich die Installation von Eclipse schon als notwendig. Besonders da ich zwar mit Java (NetBeans) schon Erfahrungen habe, aber das ist noch nicht so wild.
Danke für die ausführliche Beschreibung, die einen sehr großen Einfluß auf meine Überlegungen hat. :)
Bietet Dir Deine IDE Autocompletion von Klassen und Methoden (inkl. der Anzeige der geforderten Parameter und ihrer Typen sowie des Rückgabetyps),
Nein, ich muss schon selbst wissen, welche Klassen ich wie verwenden möchte, die Beschreibung der Sun-Bibliotheken liegt immer in einem 2.Fenster irgendwo rum. Da kann ich mir dann aussuchen, welche Variante meinen Wünschen am besten entspricht, welche "Overkill" betreibt, oder ob es noch was Besseres gibt.
automatischen Import (oder arbeitest Du mit "import java.xyx.*;"?),
Ich arbeite mit "import dingsbumsda.watt;" und bekomme einen Überblick, was der sich so alles an Land zieht.
Rebuild-On-Change (verbunden mit der sofortigen Anzeige aller Fehler, Warnungen, nicht initialisierter Variablen, ...),
2x Taste up, 1-2x enter :), und solche Schönheiten und Fingerzeige erscheinen, gilt auch für den Rest des Abschnittes. Als Anfänger muss ich da leider manchmal etwas scrollen.:o
Bietet Dir Dein Editor bequeme Unterstützung beim Erstellen und Generieren von Javadoc?
Da liegt so ein (Sun) Comand-Line-Tool rum, was so was kann, habe ich mich aber noch nicht mit beschäftigt.
Kann er automatisch Code formatieren, Code-Blöcke auskommentieren,
1. habe ich einen anderen Geschmack (ANSI),
2. bin ich schneller (/* */)und weiss, was ich getan habe.
Dann fasse ich mal zusammen:
Mein Debugger heisst System.out.println
Veraltete Methoden wirft dir javac entgegen.
Der Pfad eines Fehlers wird genauestens von java aufgelistet, und eigentlich muss man dann nur die Methode in der angegebenen Klasse finden, also im Krusader f4, suchen, eingeben, und mer ist da. F3 hoppst dann von Aufruf zu Aufruf :D
Wie viele Sekunden brauchst Du, um ein Package oder eine Klasse zu kopieren (inkl. Umbenennen)?
Keine Ahnung, auf jeden Fall brauche ich länger, um zu entscheiden, ob ich die Klasse so verwenden kann oder doch besser eine Unterklasse davon schreibe. (Klick-Ratsch F4, 2x neuen Namen eingeben, Ctrl-s, drübergucken dauert dann am längsten).
Mittlerweile habe ich natürlich auch Klassen, die in die "Privatbibliothek" gewandert sind.
Da wird je nach Verwendung einfach schnöde importiert oder ins Paket einverleibt (Klick-Ratsch, F4, 1xPaketnamen eingeben).
Wie viele Tastaturanschläge bzw. Mausklicks brauchst Du, um eine Änderung testen zu können?
ca. 3, bis das geänderte Programm läuft :)
Ich bin oft in der Situation, dass ich unter erheblichem Zeitdruck arbeiten muss - ohne eine komfortable IDE wie Eclipse wäre das nicht drin.
Das ist eine ganz andere Situation. Ich programmiere Java zum Vergnügen und kann es mir da leisten, statt 10 Tastenschlägen vielleicht 11 oder 12 eingeben zu müssen. Wenn es geschäftlich ist, muss ich ohne aufwändiges Werkzeug auskommen, sozusagen mit Bordmitteln eines Betriebssystems, von denen ein Tastaturpuffer nicht das Schlechteste ist.
Suns JDK bringt da eine ganze Menge Komfort mit, so dass ich mit Eclipse nicht unbedingt produktiver wäre.
Zudem muss man bei den meisten IDEs einen Editor der Wahl angeben, tja, und was soll das denn dann, wenn mir der Compiler, spätestens der Linker, das Runtimemodul oder was sonst noch hintendranhängt, haarklein erzählt, warum er die Zusammenarbeit verweigert.
Der Gau war ja mal der Assistent vom Qt, mit dem ich eine Spielfläche mit 64 Buttons (Reversi) aufbauen wollte. Die Oberfläche war ja schnell mittels klick-klick-copy-paste erstellt, aber die Reihenfolge der Elemente (Indices) programmiertechnisch unbrauchbar, der Code selbst total umständlich, auch ohne dass ich irgendwie "Hand angelegt" hatte :)
Übertroffen wurde das Ganze noch vom frühen Netscape-Editor zum Erstellen von HTML-Seiten. Und Dreamweaver-Seiten erkannte man schon beim Laden. :D
Nee, das Höchste, was ich mir da gefallen lasse, ist so was im Stil von J2ME, man nehme den Lieblingseditor und wähle Compiler, Packager, Verifier und Handy-Emulator per Menu an.
so long,
BlueJay
Moin,
Autocompletion:
Nein, ich muss schon selbst wissen, welche Klassen ich wie verwenden möchte, die Beschreibung der Sun-Bibliotheken liegt immer in einem 2.Fenster irgendwo rum. Da kann ich mir dann aussuchen, welche Variante meinen Wünschen am besten entspricht, welche "Overkill" betreibt, oder ob es noch was Besseres gibt.
Das Javadoc von Sun habe ich auch immer parat, aber darum ging es mir nicht. In Eclipse tippst Du einen Klassennamen (per <Ctrl>-Blank kannst Du Dich auch dabei unterstützen lassen), dann ".", und dann werden Dir alle Methoden (die mit den passenden Rückgabewerten zuerst) angezeigt. Mit jedem weiteren Buchstaben wird die Liste kleiner, so dass meist schon nach 1 - 2 Buchstaben der Methode ein beherztes <ENTER> ausreicht, um die Methode inkl. der Klammern und einem Tooltip zu haben, in dem Dir der Typ des einzusetzenden Parameters angezeigt wird. Damit bin ich wesentlich schneller (vor allem bei Konstrukten wie klasse1.methode2.methode3...) als wenn ich das manuell eintippe, und es verhindert Fipptehler ;-)
Autoimport:
Ich arbeite mit "import dingsbumsda.watt;" und bekomme einen Überblick, was der sich so alles an Land zieht.
Das Praktische an Eclipse ist, dass er Dir z. B. bei nicht eindeutigen Methoden- / Klassenbezeichnungen eine Liste aller in Frage kommenden Imports anbietet und nebenbei gleich noch nicht mehr benötigte Imports rausschmeisst (so nach dem Motto: Hashtable benutzt - ach nein, da reicht ja eine ArrayList - schwupps ist der Hashtable-Import draussen und ArrayList drin).
2x Taste up, 1-2x enter :), und solche Schönheiten und Fingerzeige erscheinen, gilt auch für den Rest des Abschnittes. Als Anfänger muss ich da leider manchmal etwas scrollen.:o
Das kriegst Du in Eclipse ganz ohne Zutun sofort serviert. Einfach die Maus auf die Markierung an der Stelle, wo ein Fehler ist, draufhalten - schon ist der Fehler erklärt.
Da liegt so ein (Sun) Comand-Line-Tool rum, was so was kann, habe ich mich aber noch nicht mit beschäftigt.
Das Ding heisst javadoc, das benutzt Eclipse auch. Aber Du kannst Dir (konfigurierbar) das Skelett dafür erstellen lassen: /** eingeben, <Enter> drücken, und schon hast Du die Parameter, Rückgabewerte und Exceptions Deiner Methode vorgegeben (gilt im Übrigen auch für Klassen- und Package-Beschreibungen). Wenn Du mit Deinem Projekt fertig bist, dann einmal "Generate Javadoc" und Du hast die Doku genauso wie die von Sun für die Verwendung im Browser fertig. Sowas ist lebenswichtig, wenn Du auch mal entspannt Urlaub machen willst ;-)
Formatieren, Auskommentieren:
1. habe ich einen anderen Geschmack (ANSI),
2. bin ich schneller (/* */)und weiss, was ich getan habe.
Wie schmeckt ANSI? Ich meinte damit die z. B. Fähigkeit, nach einem umfänglicheren Umbau eines Codeblocks per <CTRL>-i das Einrücken wieder gerade zu ziehen. Oder z. B. Tabs automatisch in Leerzeichen zu verwandeln (ich hasse Tabs - der Code sieht auf jedem Rechner und mit jedem Editor anders und meist wie Unkraut aus). Wie Code-Completion (für häufig benutzte Konstrukte) aussehen soll, kannst Du konfigurieren, .... Zu 2.: da könnten wir ja mal wetten ;-) - markieren und <CTRL>-7 - fertig. Auch eine IDE nimmt Dir das Nachdenken nicht ab, aber wenn Du z. B. eine Zeile zuviel auskommentiert hast, siehst Du in Eclipse sofort ein rotes Lämpchen.
Mein Debugger heisst System.out.println
Das ist mir viel zu aufwändig. Ich will gezielt zu den Breakpoints hüpfen können, an denen mich der Code nervt und mir dann in aller Ruhe alle aktuell gültigen Objekte und deren Properties anschauen können (oft ist ja gar nicht ersichtlich, welche davon Quatsch macht) - Du kannst übrigens in Eclipse so auch ganz bequem Collections und komplette Objekte parsen; sie auch mal zur Laufzeit ändern ... Da will ich nicht jedesmal den Code anfassen und neu kompilieren müssen. Und ich will auch mal in andere Packages / Projekte springen können (Step Into), weil doch schon mal in einer Basisklasse der Wurm stecken kann. Selbst wenn Du im aktuellen Projekt diese Klasse aus einem JAR nutzt, kannst Du sie debuggen, wenn der Quellcode mit drin steckt oder in Deinem Workspace offen ist.
Veraltete Methoden wirft dir javac entgegen.
Der Pfad eines Fehlers wird genauestens von java aufgelistet, und eigentlich muss man dann nur die Methode in der angegebenen Klasse finden, also im Krusader f4, suchen, eingeben, und mer ist da. F3 hoppst dann von Aufruf zu Aufruf :D
Genau das meine ich: Wenn Du in Eclipse entwickelst, siehst Du solche Sachen sofort beim Editieren (Runtime-Exceptions wie die berühmte NullPointerException ausgenommen, aber auch da kriegst Du Hilfe - wenn Du z. B. nicht initialisierte Objekte benutzt). Damit vermeidest Du auch Folgefehler, weil Du eben sofort auf (potenzielle) Fehlerursachen hingewiesen wirst. Dazu gehört auch, dass Du beim Editieren z. B. darauf hingewiesen wirst, wenn Du Exceptions nicht abfängst oder weiterreichst oder dass Eclipse rummault, wenn Du nicht an allen Ausstiegs-Haltestellen Deiner Methode den deklarierten Rückgabewert lieferst.
Packages, Klassen oder Methoden kopieren:
Keine Ahnung, auf jeden Fall brauche ich länger, um zu entscheiden, ob ich die Klasse so verwenden kann oder doch besser eine Unterklasse davon schreibe. (Klick-Ratsch F4, 2x neuen Namen eingeben, Ctrl-s, drübergucken dauert dann am längsten).
Das meine ich nicht. Ich habe manchmal die Situation, dass ich für individuelle Kundenanpassungen Klassen ähnlich wie bei anderen - aber eben nicht identisch - bauen muss. Dann suche ich mir meist die am besten passende Klasse (egal in welchem Projekt meines Workspace), mache einmal <Strg>-c, <Strg>-v und schon habe ich eine Kopie. Wenn es Namenskollisionen gibt oder ich bewusst umbenennen will, dann sorgt Eclipse dafür, dass auch alle Referenzen, Text-Matches usw. angepasst werden (ggf. im Dialog, wenn Eclipse nicht entscheiden kann, ob in Package X, Klasse Y die Methode Z auch umbenannt werden muss). Du musst nicht erst suchen oder per Find/Replace womöglich zu viel umbenennen, weil Du gleich die Übersicht (inkl. Code-Ausschnitt) darüber hast.
Mittlerweile habe ich natürlich auch Klassen, die in die "Privatbibliothek" gewandert sind.
Da wird je nach Verwendung einfach schnöde importiert oder ins Paket einverleibt (Klick-Ratsch, F4, 1xPaketnamen eingeben).
Selbstverständlich, Wiederverwendbarkeit soll ja angeblich eine der großen Errungenschaften von OOP sein ;-) - da gibt es bei uns z. T. sehr umfangreiche Frameworks. Aber auch da gibt es Situationen, in denen Du in irgendeiner selten verwendeten Methode oder mit ausgefallenen Parametern eine Klasse auf dem falschen Fuß erwischst. Und da ist es eben schön, wenn Du die auch mal schnell debuggen kannst und nicht Stunden oder Tage mit der Fehlersuche in Deinem Code zubringst.
Änderungen testen:
ca. 3, bis das geänderte Programm läuft :)
Ätsch: 1 ;-) (SCNR) Und ich sehe die Programmausgabe ohne Fensterwechsel innerhalb der IDE.
Suns JDK bringt da eine ganze Menge Komfort mit, so dass ich mit Eclipse nicht unbedingt produktiver wäre.
Ich empfehle Dir, mal die Zeit zu investieren und die Möglichkeiten von Eclipse mal intensiv und unvoreingenommen auszuprobieren.
Zudem muss man bei den meisten IDEs einen Editor der Wahl angeben...
In Eclipse nicht. Überhaupt ist der eingebaute Eclipse-Editor (zumindest für Java) meiner Meinung nach einer der besten, die ich je erlebt habe. Der aus M$-VisualStudio z. B. erzeugt bei mir jedesmal Brechreiz. Eclipse bietet an fast allen Stellen sinnvolle Defaults (ohne Dich dabei zu hindern, bis zum Koma Konfigurationseinstellungen anzupassen), so dass Du eigentlich sofort nach Installation loslegen kannst. Was für mich auch sehr wichtig ist: Du kannst für jedes Projekt entscheiden, mit welcher JRE-Version Du arbeitest und welche Code-Kompatibilität (1.4, 5.0, ...) Eclipse benutzen soll, um Dir auf die Finger zu schauen. Ich muss nämlich sowohl Kunden mit 1.4 als auch mit 5.0 bedienen können. Und bei einem Upgrade meiner Projekte habe ich das volle Verständnis von Eclipse ;-)
Ich will nicht behaupten, dass Eclipse immer und in jeder Situation die eierlegende Wollmilchsau ist (in Sachen GUI-Entwicklung z. B. hinkt Eclipse AFAIK hinter NetBeans hinterher - ich bin aber noch nicht dazu gekommen, mir das näher anzugucken, ich bin meist auf Serverseite unterwegs), aber das Ding hat bei mir bisher am schnellsten und nachhaltigsten Punkte gegenüber anderen IDEs (VB, Delphi, KDevelop, VisualStudio, QtDesigner, ...) und Editoren (vim, SCiTE, UltraEdit, Kate, ...), die ich gezwungenermaßen oder aus eigenem Entschluss probiert habe, gesammelt. Das liegt sicher auch am Charme von Java (und dessen Riesenangebot an Bibliotheken) und den unzähligen verfügbaren Eclipse-Plugins, aber eben auch daran, dass ich bald gemerkt habe, wie schnell und sauber ich damit Code erzeugen kann.
Jan
P.S.: Für Shell, Perl, Tcl, PHP & Co, nehme ich nach wie vor vim (oder Kate, wenn es schlimm kommt und es mehr als 5 Module werden) :)
Hallo,
ich möchte auch mal meine Meinung kund tun.
Wenn es um Java-Programmierung geht, arbeite ich am liebsten mit eclipse.
Wenn ich mal schnell ein shell-Script schreibe, dann nehme ich den vi.
@BlueJay
Also ich glaube, dass du bei einem paar Zeilen-Programm mit deinem Editor schneller bist, als ich mit eclipse. Ich glaube aber nicht, dass es bei größeren Applicationen so ist.
Ich arbeite mit an einem Project, welches mehrere tausend Klassen hat. Zudem nutzen wir ein Versions-Controll-System. Also wenn ich mir überlege da mit einem normalen Editor zu arbeiten. Das ist fast unmöglich. Da würde ich am Tag ja gar nichts garbeitet bekommen.
In eclipse muss man sich GUIs ja auch nicht zusammen klicken, man kann sie auch selbst schreiben. Eclipse nimmt mir auch ne Menge arbeit ab. Trotzdem weiß ich immer noch was ich mache und was passiert. Wenn ich Beispielsweise ein Interface mit 20 Methoden implementiere, reicht bei eclipse 3 Tastendrücke und ich hab alle Methoden fertig da stehen und muss nicht noch alles selbst schreiben.
Zum Thema Debugger. Also ich hab schon Situationen gehabt, da ist man nur mit sysouts nicht weit gekommen. Beim Debugger, kann man leicht sich mal schnell den Inhalt von Objection während der Laufzeit anschauen. Ich möchte mal sehen, wie du das mal schnell mit nem sysout gemacht hast.
Bei einem Anfänger verstehe ich es, wenn er noch mit einem "normalen" Editor programmiert. So lernt er am besten. Wenn man das aber schon kann, ist es blödsinn auch noch die kleinsten Arbeiten selbst zu erledigen.
Warum soll ich meine Zeit vergeuden um Methodenköpfe zu tippen, wenn ich ein Interface implementiere, wenn jemand das für mich machen kann?
Warum sollte ich meine Zeit mit imports verschwenden, wenn jemand die für mich schreiben kann und ich sehe was er schreibt?
MFG
zEriX
anda_skoa
13-12-2007, 19:13
Da würde ich am Tag ja gar nichts garbeitet bekommen.
Also ich wäre vorsichtig mit solchen Aussagen. Eine IDE zur Automatisierung verschiedener Vorgänge heranzuziehen ist eine Sache, praktisch davon abhängig zu sein eine andere.
Kommt leider oft genug vor, dass Bewerber für eine Stelle solche IDE-Künstler sind, die dann nichtmal einen Remote-Build starten können.
Wenn ich Beispielsweise ein Interface mit 20 Methoden implementiere, reicht bei eclipse 3 Tastendrücke und ich hab alle Methoden fertig da stehen und muss nicht noch alles selbst schreiben.
Das mag jetzt in Zeiten der Über-IDEs eigenartig erscheinen, aber automatisierte Abläufe können Programmierereditoren schon länger.
Zum Thema Debugger. Also ich hab schon Situationen gehabt, da ist man nur mit sysouts nicht weit gekommen. Beim Debugger, kann man leicht sich mal schnell den Inhalt von Objection während der Laufzeit anschauen. Ich möchte mal sehen, wie du das mal schnell mit nem sysout gemacht hast.
Es ist schon klar, dass ein Debugger auch seine Einsatzgebiete hat, aber in den meisten Fällen ist man mit entsprechendem Logging einfach schneller, auch weil man mit Loggingframeworks alles "drinnen" lassen kann und bei Bedarf aktiviert.
Der wesentliche Vorteil von Logging gegenüber Debugger ist, dass das Verhalten der Applikation näher am tatsächlichen Verhalten liegt, d.h. man kann es auch einsetzen, wenn man mit Threads oder GUI zu tun hat, Anwendungebereiche wo das Anhalten einer Exekutionskette praktisch einen im Normalbetrieb nicht erreichbaren Zustand erzeugt.
Warum soll ich meine Zeit vergeuden um Methodenköpfe zu tippen, wenn ich ein Interface implementiere, wenn jemand das für mich machen kann?
Wie gesagt, es spricht nichts gegen Automatisierung, nur spricht auch nichts dagegen, dafür einen Editor zu benutzen.
Im Falle von Codegenerierung, d.h. Klassen, Methoden, etc., sind die Möglichkeiten von IDEs oft sogar eingeschränkter, d.h. verfügen manchmal nur über einen oder wenige Codingstyle Optionen, etc.
Wird mit der Zeit natürlich besser, viele IDEs können solche Aufgaben mittlerweile an Plugins delegieren.
Ciao,
_
Moin,
Also ich wäre vorsichtig mit solchen Aussagen. Eine IDE zur Automatisierung verschiedener Vorgänge heranzuziehen ist eine Sache, praktisch davon abhängig zu sein eine andere.
Abhängig ist man dann, wenn man die Konzepte der Sprache nicht kennt. Das hat erstmal nichts damit zu tun, ob man eine IDE benutzt. Und abhängig ist man immer - von einem Editor, einer Build-Umgebung, einem Versionskontrollsystem, ... Bei einer IDE ist man das nur auf einer höheren Ebene (was dabei in Eclipse IMHO so gut ist: Du kannst bis zum Umfallen automatisieren, Du musst es aber nicht - Du kannst die Imports manuelle eintragen, wenn Du Lust hast, Du kannst Deinen javac manuell aufrufen, wenn Dich das befriedigt, ...). Ich möchte z. B. mal sehen, wie ein eingefleischter Nutzer des Betriebssystem emacs sich mit einem vi rumschlägt ;-) - oder mich mit emacs.
Kommt leider oft genug vor, dass Bewerber für eine Stelle solche IDE-Künstler sind, die dann nichtmal einen Remote-Build starten können.
Wer davon eine Stelle abhängig macht, ist selber schuld. Den Umgang mit IDEs, Build-Umgebungen, Editoren usw. kann man lernen. Ich habe in diversen Arbeitsstellen und bei etlichen Kunden bisher immer wieder neue Exemplare davon benutzen müssen - es geht gar nicht anders. Was IMHO zählen sollte, ist die Fähigkeit, aus den Problemen des Kunden ein Projekt zu machen und mit der Sprache der Wahl daraus funktionierende Programmumgebungen zu erzeugen. Je schneller, desto besser.
Es ist schon klar, dass ein Debugger auch seine Einsatzgebiete hat, aber in den meisten Fällen ist man mit entsprechendem Logging einfach schneller, auch weil man mit Loggingframeworks alles "drinnen" lassen kann und bei Bedarf aktiviert.
Sehe ich anders. Genau die Objekteigenschaft, die man nicht loggt, ist meist die, die Probleme macht. Und wenn die Stelle, die Probleme macht, genau die Logging-Ausgabe ist (z. B. ein NullPointer-Objekt, dessen Eigenschaft Du erst protokollierst und dann benutzt)? Komfortables Debugging ist meiner Ansicht nach nicht zu ersetzen. Gerade in umfangreichen Projekten hast Du es allein mit Logging schwer, die Übersicht zu behalten: Wie war nochmal die Variable XYZ belegt? Steht im Log 200 Zeilen weiter oben. Eh Du im Log an der Stelle bist, hast Du in Eclipse mit ein paar Mausklicks den Fehler identifiziert, behoben, getestet und das .jar neu gebaut ;-)
Der wesentliche Vorteil von Logging gegenüber Debugger ist, dass das Verhalten der Applikation näher am tatsächlichen Verhalten liegt, d.h. man kann es auch einsetzen, wenn man mit Threads oder GUI zu tun hat, Anwendungebereiche wo das Anhalten einer Exekutionskette praktisch einen im Normalbetrieb nicht erreichbaren Zustand erzeugt.
Das ist für mich eher die Ausnahmesituation, wo man mit einem Log eher einen Fehler aufspürt als im Debugger. Und wenn es um Probleme mit der Nebenläufigkeit von Threads geht, dann hast Du meist unsauber programmiert, die Möglichkeiten von Java nicht ausgenutzt (z. B. keine Serialisierung vorgenommen). Und auch hier unterstützt Dich Eclipse.
Wie gesagt, es spricht nichts gegen Automatisierung, nur spricht auch nichts dagegen, dafür einen Editor zu benutzen.
Im Falle von Codegenerierung, d.h. Klassen, Methoden, etc., sind die Möglichkeiten von IDEs oft sogar eingeschränkter, d.h. verfügen manchmal nur über einen oder wenige Codingstyle Optionen, etc.
Automatisierung ist nur ein Aspekt der Vorteile einer IDE. Der tatsächliche Produktivitätsschub ergibt sich aus der Summe der Möglichkeiten und der (im Fall von Eclips meist nahtlosen) Integration unter einer Haube. Und was "eingeschränkte Möglichkeiten" angeht: Ich habe es schon geschrieben, Du kannst in Eclipse bis zum Umfallen konfigurieren.
Die Diskussion IDE vs. Editor/Kommandozeile kann man sicher noch eine kleine Ewigkeit weiterführen, das hängt auch immer viel von persönlichen Vorlieben und Erfahrungen ab. Ich für meinen Teil bin vom Editor gekommen, bei Eclipse gelandet und bleibe auch dabei, da meine Erfahrungen mir eben gezeigt haben, dass ich damit um Längen schneller bei einem vernünftigen Resultat bin. Zeit spielt in einer Firma eine entscheidende Rolle.
Jan
Ich hatte auch mit einem Editor begonnen und hab mir auch unterschiedliche IDEs angeschaut. Ich bin bei eclipse geblieben.
Ich sagte ja für einen Anfänger ist es nur Vorteilhaft, wenn er mit einem Editor programmiert, als mit irgendeiner Entwicklungsumgebung. Damit man sich auch erstmal mit der Sprache auseinander setzen muss. Wenn man sich noch nicht mit der Sprache auskennt, sollte man keine IDE verwenden.
Meiner Meinung nach ist die Produktivität bei größeren Projekten bei weitem nicht so hoch, wenn man einen Editor nutzt.
Zum Thema Debugger. Mit Logging kann man schon Fehler finden, aber wie jan61 schon sagte, es ist eher die Ausnahme. Die meisten Fehler kann man nicht durch das Standard-Logging finden. Es sei denn jede Zeile wird mitgeloggt mit allen Daten von allen Objecten.
Wie findest du zum Beispiel mit Logging raus, welche Objecte mit welchen Werten sich in einer ArrayList befinden. Oder wie merkst du, dass aus einem TreeSet das falsche Object gelöscht wird?
Meine Meinung ist, dass auch wenn die Vorlieben beim Editor liegen, man bei größeren Objecten nicht an Entwicklungsumgebungen vorbeikommt, wenn man Konkurenzfähig bleiben möchte. Da man meiner Meinung nach, mit einer IDE ein Projekt viel schneller "hochziehen" kann, weil man sich um weniger Sachen kümmern muss.
MFG
zEriX
Beim Debugger, kann man leicht sich mal schnell den Inhalt von Objection während der Laufzeit anschauen. Ich möchte mal sehen, wie du das mal schnell mit nem sysout gemacht hast.
Mit der toString-Methode. Manchmal muss man danach etwas scrollen, besonders, wenn man in Threads untersucht. ;)
Warum soll ich meine Zeit vergeuden um Methodenköpfe zu tippen...
Warum sollte ich meine Zeit mit imports verschwenden, wenn jemand die für mich schreiben kann und ich sehe was er schreibt?
SCNR:
Warum sollte ich meine Zeit vergeuden, wenn jemand anderes für mich programmieren kann? :)
Kann dein Editor folgendes?
alle vars in die richtigen ints, doubles und booleans verwandeln?
alle functions in die richtigen static dingsbumsdas verwandeln zusammen mit ihren Parametern?
so long,
BlueJay
anda_skoa
14-12-2007, 15:25
Wer davon eine Stelle abhängig macht, ist selber schuld.
Ich meinte das umgekehrt, d.h. Bewerber waren ansich programmiertechnisch akzeptabel, aber nur in der von ihnen gewohnte IDE, wie gesagt inklusive Fälle, wo jemand nicht mal "make" kannte/konnte.
Sehe ich anders. Genau die Objekteigenschaft, die man nicht loggt, ist meist die, die Probleme macht.
Logging zur Fehlersuche setzt natürlich vorraus, dass der Entwickler weiß was der Code tun sollte und welche Eigenschaften als Problemquelle in Frage kommen. Problemanalyse und so.
Und wenn die Stelle, die Probleme macht, genau die Logging-Ausgabe ist (z. B. ein NullPointer-Objekt, dessen Eigenschaft Du erst protokollierst und dann benutzt)?
Wenn ich eine NullPointer Referenz benutze, bekomme ich immer eine Exception. Dachte das ist immer so.
Komfortables Debugging ist meiner Ansicht nach nicht zu ersetzen. Gerade in umfangreichen Projekten hast Du es allein mit Logging schwer, die Übersicht zu behalten: Wie war nochmal die Variable XYZ belegt? Steht im Log 200 Zeilen weiter oben.
Erstens ist gutes Logging verteilt, d.h. geht zum Beispiel in verschiedene Dateien.
Zweitens ist entsprechend formatierter Logoutput sehr einfach maschinell zu untersuchen, u.a. mit grep oder ähnlichen Tools.
Eh Du im Log an der Stelle bist, hast Du in Eclipse mit ein paar Mausklicks den Fehler identifiziert, behoben, getestet und das .jar neu gebaut ;-)
Das schau ich mir. Wie entscheidest du, zu welchem Zeitpunkt du den normalen Lauf des Programms unterbrichst, um dir Werte anzusehen?
Wenn der Fehler bemerkbar wird und hoffen, dass inzwischen keine weitere Zustandsänderung vorgenommen wurde?
Einen Breakpoint setzten und eine Stunde lang (oder wie lange auch immer es dauert bis der Problem auftritt, Tage vielleicht) im Debugger "continue" klicken?
Und wenn es um Probleme mit der Nebenläufigkeit von Threads geht, dann hast Du meist unsauber programmiert, die Möglichkeiten von Java nicht ausgenutzt (z. B. keine Serialisierung vorgenommen).
Es geht nicht um de Nebenläufigkeit, sondern um das massive Verändern des Laufzeitverhaltens.
Sobald irgendwo im Programm mit zeitabhängigen Werten gearbeitet wird, z.B. Timeouts, Zeitstempel, etc., sind ein paar Millisekunden für den Logoutput meistens noch vertretbar.
Bei GUI ist das ähnlich, das Umschalten von einem Programmfenster auf ein Debuggerfenster löst Events aus, die dann im Laufe des Debuggings zu künstlichen Zustandsänderungen führen können.
Ciao,
_
mehlvogel
14-12-2007, 22:09
Das ganze ist wie hier mehrfach erwähnt wurde, eine persönliche Sache. Jeder arbeitet nunmal so, wie er sich daran gewöhnt hat. Den einen ist das der Luxus, den eine vollständig integrierte IDE wie Eclipse oder Net Beans liefert, seien es Code Assistenten, Conditional Breakpoints, einen vernünftigen Debugger oder große Refactor Möglichkeiten. Den anderen reicht ihr Editor und ein paar Konsolen auf denen sie ihre Arbeit vollrichten, ihre Logs betrachten, compiler anschmeissen und das ganze während sie in dem Editor der gerade Kaffee kocht auch noch ihre Mails checken und das alles mit nur ein paar Tastenkombinationen. Der Punkt ist, dass jede Seite ihre Vorurteile gegen die anderen und die angeblichen Argumente für die eigene hat. Ihr werdet hier auf keinen grünen Zweig kommen... Jeder ist dann am effizientesten, wenn ihm seine Arbeitsumgebung so unterstützt wie er das möchte und nicht wenn er unter Zwang in einer völlig überladenen GUI in zig Untermenüs die Optionen suchen muss, oder in 1000 Fenstern eine fantastillionen Befehle eintippen muss, um das zu erreichen was er möchte.
rausschmeisst (so nach dem Motto: Hashtable benutzt - ach nein, da reicht ja eine ArrayList - schwupps ist der Hashtable-Import draussen und ArrayList drin).
IECKS! :eek:
Und wenn ich nachher erweitern will, ist meine Hashtable weg?
Ich geb jetzt auch noch meinen Senf dazu: Informatiker sind ja stets der Ansicht, dass man Code einmal schreibt und ihn dann so lange debuggt, bis man keine Fehler mehr findet. Dies ist aus Sicht eines Elektrotechnikers natürlich absoluter Schwachsinn - denn so wirst du nie alle Fehler finden und ständig am patchen sein (geschweige denn von Sicherheitslücken, Problemen die nur unter bestimmten Bedingungen eintreffen,...). "First time right" sollte eigentlich die Devise sein - und da hilft eine IDE meines Erachtens nicht ;)
MfG Bischi
bischi: darum gibt es ja auch Bemühungen der Informatiker effiziente Methoden zur formalen Verifikation von Programmen zu finden (ja ich bin Informatik-Student :))
Naja, ich gehör auch eher zur Editor+Konsolen-Fraktion. Hab mir aber gerade eben wieder einmal Code::Blocks angesehen und muss sagen, es sieht nicht schlecht aus (bis auf das kleine Problem, dass <ESC>:w nicht speichert :D )
Ich gebs ja zu - meine Aussage war ein wenig plakativ und trifft sicherlich nicht auf alle Informatiker zu. Aber ne gewisse Tendenz ist schon da ;)
MfG Bischi
Informatiker sind ja stets der Ansicht, dass man Code einmal schreibt und ihn dann so lange debuggt, bis man keine Fehler mehr findet.
Einspruch!
Die Ur-Informatiker stammen von Mathematikern ab, zumindest die Bochumer Fraktion. Da beginnt die Fehlersuche normalerweise schon vor dem Erstellen des Quältextes. Wenn man dann so weit ist, hat der Compiler zu parieren.
Tja, und dann ging es denen wie Reinhard Mey mit seiner 11X/13 :rolleyes:
so long,
BlueJay
IECKS! :eek:
Und wenn ich nachher erweitern will, ist meine Hashtable weg?
Nein, dann ist sie mit "Organize Imports" (oder dem entspr. Shortcut <Shift><Ctrl>-o) wieder drin - oder ich tippe Ha<Ctrl>-<Space> und wähle aus der Drop-Down-Liste aus (was mir wiederum Ärger erspart, wenn ich nicht mehr genau weiß, ob es nun Hashtable oder HashTable heißt) - dann ist auch automatisch der Import da.
Jan
P.S.: Ich hatte es schon mal empfohlen - guck Dir eclipse einfach mal an. Wenn die IDE so dämlich wäre, wie Du oben vermutet hast, dann wäre sie wohl kaum so verbreitet.
Nein, dann ist sie mit "Organize Imports" (oder dem entspr. Shortcut <Shift><Ctrl>-o) wieder drin
(grummel, dass eclipse sich überhaupt erdreistet!)
(was mir wiederum Ärger erspart, wenn ich nicht mehr genau weiß, ob es nun Hashtable oder HashTable heißt) - dann ist auch automatisch der Import da.
Isset türkis, haste den Namen richtig getroffen :)
Schlägt dir Eclipse dann auch die Sache mit den Extra-Klämmerchen vor?
Sonst ist Javadoc besser.
Ich hatte mal Eclipse auf Platte, habe dann aber nach Anlegen eines Projektes meine Files nicht gefunden, oder irgendwas ist da mit dem Anlegen eines Packages schiefgelaufen.
Das war dann der Zeitpunkt, an dem ich mich entschloss, auch Java-Applications als "Bitbeisser" zu programmieren.
so long,
BlueJay
Ich hatte mal Eclipse auf Platte, habe dann aber nach Anlegen eines Projektes meine Files nicht gefunden, oder irgendwas ist da mit dem Anlegen eines Packages schiefgelaufen.
Diese Probleme hatte ich bisher noch nie und ich nutze schon seit Jahren eclipse.
Was ich zum Beispiel noch als Vorteil sehe sind die ganzen Refactor-Möglichkeiten. Ich muss nicht unmengen von Klassen anpacken, wenn ich was ändern möchte.
Das schau ich mir. Wie entscheidest du, zu welchem Zeitpunkt du den normalen Lauf des Programms unterbrichst, um dir Werte anzusehen?
Wenn der Fehler bemerkbar wird und hoffen, dass inzwischen keine weitere Zustandsänderung vorgenommen wurde?
Einen Breakpoint setzten und eine Stunde lang (oder wie lange auch immer es dauert bis der Problem auftritt, Tage vielleicht) im Debugger "continue" klicken?
Bei den meisten Problemen, kann man schon eingrenzen wo der Fehler ungefähr ist.
Ich hab aber bisher noch nie alle Elemente eines TreeSets o. ä. mitgeloggt. Ich musste ein einem Code der nicht von mir stammt einen Fehler suchen. Durch den Debugger habe ich dann rausgefunden, dass immer das falsche Object aus dem TreeSet entfernt wird, weil der Comparator nicht richtig implementiert war. Ich wüsste nicht wie man mit Logging sowas rausfindet.
Unter anderem haben wir durch Debugging mal einen Fehler in der Java-Implementation gefunden. Wie loggt man denn die Java-Internen Sachen mit?
Achja, unter Windows kann man grep nicht nutzen. Und wenn man sonst auch keine Zusatzsoftware hat, ist es schwer mit dem Filtern von Log-Dateien.
Zusätzlich kann man mit Eclipse Dateien vergleichen, mergen o.ä.. eclipse hat eine Local-History mit der man auch leicht an alte Versionen seiner Datei kommt.
Ich wüsste nicht warum ich mir mehrere Programme installieren soll, wenn man mit einem Programm (fast) alles kann.
MFG
zEriX
Durch den Debugger habe ich dann rausgefunden, dass immer das falsche Object aus dem TreeSet entfernt wird, weil der Comparator nicht richtig implementiert war. Ich wüsste nicht wie man mit Logging sowas rausfindet.
Nu ja, Zustand vorher, Zustand nachher vergleichen.
System.out an bestimmten Stellen heisst ja, checken, ob die Werte an bestimmten (kritischen) Stellen den Erwartungswerten entsprechen.
Auf diese Art und Weise fand ich sogar mal seinerzeit nur mit alert ein falsch implementiertes Array.push/Array.pop in Javascript, und das ziemlich schnell.
Achja, unter Windows kann man grep nicht nutzen. Und wenn man sonst auch keine Zusatzsoftware hat, ist es schwer mit dem Filtern von Log-Dateien.
Richtig, wenn ich an Windows und programmieren denke, kriege ich (noch mehr) graue Haare! Mit Linux ist man da ja auf der Insel der Seligen ;)
Für die ist Eclipse wohl dann so was, was für mich Krusader und das JDK ist.
Ich wüsste nicht warum ich mir mehrere Programme installieren soll, wenn man mit einem Programm (fast) alles kann.
So isses!
so long,
uja
Nu ja, Zustand vorher, Zustand nachher vergleichen.
System.out an bestimmten Stellen heisst ja, checken, ob die Werte an bestimmten (kritischen) Stellen den Erwartungswerten entsprechen.
Auf diese Art und Weise fand ich sogar mal seinerzeit nur mit alert ein falsch implementiertes Array.push/Array.pop in Javascript, und das ziemlich schnell.
An dieser Stelle wurde einfach ein Element aus der Liste entfernt. Da denkt ja niemand, dass das falsche entfernt wird. Es war eigentlich auch keine Stelle, die besonders kritisch oder wichtig war. Von daher wird da auch nicht geloggt. Wenn ich überall hätte die Listen Ausgeben müssen, hätte ich pro Liste mindestens 8 Sysouts haben müssen in 2 Schleifen, damit mir nicht unnötig viele Daten ausgegeben werde. Und ich hätte das an vielen Stellen machen müssen. So hab ich einfach nen Breakpoint gesetzt. Das Programm hat gestoppt . Ich hab es mir angeschaut, während dem laufenden Programm den Code geändert und siehe da, es hat funktioniert ohne das Programm neu starten zu müssen oder ähnliches.
Anders hätte es bestimmt auch funktioniert. Es wäre nur viel mehr Arbeit gewesen.
Richtig, wenn ich an Windows und programmieren denke, kriege ich (noch mehr) graue Haare! Mit Linux ist man da ja auf der Insel der Seligen
Ich musste bisher leider immer unter Windows programmieren und es ist auch nicht so leicht hier neue Software genehmigt zu bekommen. Zuhause hab ich Linux, aber nutze dort auch eclipse. ;-)
MFG
zEriX
anda_skoa
17-12-2007, 14:36
Bei den meisten Problemen, kann man schon eingrenzen wo der Fehler ungefähr ist.
Nun ja, vermutlich kann ich einfach nicht so gut raten an welcher Stelle das Programm gerade stand bzw. welchen Datenbestand es gerade hatte, als es vor zwei Tagen in der Nacht einen falschen Output geliefert hat.
Gute Logging hilft da schon mal, nicht den ganzen Tag als Testlauf wiederholen zu müssen.
Ich hab aber bisher noch nie alle Elemente eines TreeSets o. ä. mitgeloggt. Ich musste ein einem Code der nicht von mir stammt einen Fehler suchen. Durch den Debugger habe ich dann rausgefunden, dass immer das falsche Object aus dem TreeSet entfernt wird, weil der Comparator nicht richtig implementiert war. Ich wüsste nicht wie man mit Logging sowas rausfindet.
Wenn das TreeSet irgendwann in einem falschen Zustand ist, dann bietet sich als Ansatzpunkte die Stellen an, an denen das Set verändert wird.
Ich mach das jedenfalls so, ich nenne das Fehleranalyse.
Unter anderem haben wir durch Debugging mal einen Fehler in der Java-Implementation gefunden. Wie loggt man denn die Java-Internen Sachen mit?
Ich sagte nicht, dass es immer mit Logging geht, nur das es in den meisten Fällen einfacher ist und in manchen Fällen mit Debugging praktisch gar nicht machbar ist.
Logischerweise gibt es daher auch Fälle, die nur mit Debugging möglich sind.
Allerdings ist die Frage, wie du einen Breakpoint setzt, wenn du den Code des jeweiligen Programmteils nicht hast.
Achja, unter Windows kann man grep nicht nutzen. Und wenn man sonst auch keine Zusatzsoftware hat, ist es schwer mit dem Filtern von Log-Dateien.
Wenn man statt einer Workstation ein Homeentertainmentsystem benutzt, muss man natürlich haufenweise Zusatzsoftware nachinstallieren.
Man ist dann schon fast auf eine IDE angewiesen, weil man nicht mal virtuelle Workspaces hat.
Wenn man unter diesen Widrigkeiten arbeiten muss, hat man echt Pech gehabt und verdient auch das Mitleider aller Kollegen.
Aber vermutlich können alle aktuellen IDEs mit regulären Ausdrücken umgehen, bzw. verkettete Suche drüchführen?
Zusätzlich kann man mit Eclipse Dateien vergleichen, mergen o.ä.. eclipse hat eine Local-History mit der man auch leicht an alte Versionen seiner Datei kommt.
Boah, eh!
Womöglich auch noch branchen?
Ich wüsste nicht warum ich mir mehrere Programme installieren soll, wenn man mit einem Programm (fast) alles kann.
Niemand sagt, dass man das muss.
Es sagt aber auch niemand, dass man sich ein Kann-(fast)-alles Programm installieren muss, wenn man ohnehin schon alles installiert hat, was man braucht.
Logging muss immer sein, ob man mit einer IDE arbeitet oder mit einem Editor. Meiner Meinung nach hat man aber mit einem Debugger den Fehler westenlich schneller gefunden, als mit Logging/Sysouts. Man kann immerhin nicht alles mit loggen oder ich muss ständig sysouts irgendwo einfügen, was ich durch einen Debugger nicht muss.
Wenn das TreeSet irgendwann in einem falschen Zustand ist, dann bietet sich als Ansatzpunkte die Stellen an, an denen das Set verändert wird.
Ich mach das jedenfalls so, ich nenne das Fehleranalyse.
Wenn ein TreeSet öfter verändert wird, muss ich aber sehr viele Sysouts einfügen, also ich muss den Code ändern. Mit Debugger bleibt der Code erstmal unberührt.
Wenn man statt einer Workstation ein Homeentertainmentsystem benutzt, muss man natürlich haufenweise Zusatzsoftware nachinstallieren.
Man ist dann schon fast auf eine IDE angewiesen, weil man nicht mal virtuelle Workspaces hat.
Wenn man unter diesen Widrigkeiten arbeiten muss, hat man echt Pech gehabt und verdient auch das Mitleider aller Kollegen.
Wir arbeiten hier noch mit Windows 2000 und es gibt nicht wenige Firmen die auch mit Windows arbeiten.
Aber vermutlich können alle aktuellen IDEs mit regulären Ausdrücken umgehen, bzw. verkettete Suche drüchführen?
Das ist ein Feature von grep o.ä.. Ich glaube kaum, dass dein Editor das kann. Eine Idee ist auch nicht zum durchsuchen von Log-Files, oder?
Während man mit einer IDE 90% der Arbeit erledigen kann und mit einem Editor vielleicht mal 50%, ziehe ich die IDE vor. Da muss ich nicht ständig zwischen mehreren Programmen wechseln.
Ich kann auch eclipse als "normalen" Editor verwenden und alles andere mit den anderen Programmen erledigen, aber wozu sollte man es sich unnötig schwer machen. eclipse oder auch die anderen IDEs haben eine Menge nützlicher Features, die viel Arbeit abnehmen und Zeit sparen.
Kannst du zum Beispiel bei dir auf eine Methode klicken die aufgerufen wird und dann öffnet sich direkt die Klasse zu dieser Methode?
Durch die Refactoring-Tools kann man leicht den Code refactoren ohne dass man mal eine Stelle vergisst und der Code auf einmal nicht mehr funktioniert.
Das man auch ohne IDE seine Arbeit verrichten kann, bestreite ich ja gar nicht. Ich bin lediglich der Meinung, dass man mit einer IDE wesentlich kompfortabler und schneller erledigen kann.
MFG
zEriX
Man kann immerhin nicht alles mit loggen oder ich muss ständig sysouts irgendwo einfügen, was ich durch einen Debugger nicht muss.
Na, ob man Breakpoints oder Sysouts einfügt und wieder rauschmeisst, ist doch Hose wie Jacke. Und zumindest in meinem alten Pascal-System musste man die Breakpoints wieder rausschmeissen, oder es gab Performanceverlust. Sysouts melden sich wenigstens, wenn man einen vergessen hat. ;)
Während man mit einer IDE 90% der Arbeit erledigen kann und mit einem Editor vielleicht mal 50%, ziehe ich die IDE vor. Da muss ich nicht ständig zwischen mehreren Programmen wechseln.
Kann Windows immer noch kein Multitasking? :p
Das man auch ohne IDE seine Arbeit verrichten kann, bestreite ich ja gar nicht. Ich bin lediglich der Meinung, dass man mit einer IDE wesentlich kompfortabler und schneller erledigen kann.
Und wie geht das nun mit dem COM-Port, C++ und Eclipse?
http://www.mrunix.de/forums/showthread.php?p=253141#post253141
:D
mehlvogel
17-12-2007, 18:56
Und zumindest in meinem alten Pascal-System musste man die Breakpoints wieder rausschmeissen,
Die Betonung liegt hier auf alt ;)
Edith sagt wieder dass die Diskussion witzlos ist, da es scheinbar so ist, dass jeder nur gefährliche Halbwahrheiten über die andere Seite hat...
...Isset türkis, haste den Namen richtig getroffen :)
Toll, und wie lange muss ich dann probieren (es gibt ja nicht nur Hashtable, wo es im Zweifelsfall 1 Buchstabe ist, den man falsch schreibt)?
Schlägt dir Eclipse dann auch die Sache mit den Extra-Klämmerchen vor? Sonst ist Javadoc besser.
Falls Du Typisieren von Collections bei Java-5.0-Kompatibilität meinst - ja, da gibt es Mecker, wenn ich nicht typisiere oder Errors, wenn ich falsche Typen zuweise - gleich, nicht erst zur Laufzeit.
Ich hatte mal Eclipse auf Platte, habe dann aber nach Anlegen eines Projektes meine Files nicht gefunden, oder irgendwas ist da mit dem Anlegen eines Packages schiefgelaufen.
Das war dann der Zeitpunkt, an dem ich mich entschloss, auch Java-Applications als "Bitbeisser" zu programmieren.
Selbstverständlich muss man sich in eine IDE einarbeiten (wie auch in einen vernünftigen Editor, ein Buildsystem, ...). Aber dass Du Deine Dateien nicht gefunden hast ... <hüstel> - Du kennst find (falls Du damit nicht klarkommst - ich beantworte gerne Deine Fragen im Script-Forum ;-)? Ganz nebenbei - in Eclipse Rechtsklick auf die Datei -> "Properties" und schwupps steht da der Pfad relativ zum Workspace und die Location als absoluter Pfad.
Mal allgemein zu diesem Thread: Ich nehme es Dir und anda_skoa ja ab, dass Ihr lieber mit Editor + javac + [make|ant] + System.out (warum eigentlich nicht mit sed, awk, grep & Co.? SCNR) arbeiten wollt, aber ich glaube langsam nicht mehr, dass Ihr halbwegs unvoreingenommen an Eclipse rangeht. Für mich (Achtung: persönliche Meinung!) sieht es mittlerweile eher nach dem "IDE=Warmduscher"-Klischee aus.
Ich gönne Euch ja Eure Erfolgserlebnisse mit Eurer perfekten Werkzeugsammlung, aber Ihr solltet auch akzeptieren, dass z. B. zerix & ich (für meinen Teil nach langen Erfahrungen mit editor-gestützter Java-Entwicklung) mit einer ausgereiften IDE wie Eclipse eben sehr gute Erfahrungen gemacht haben - die Gründe dafür haben wir beide ausführlich erklärt.
Jan
@anda_skoa: Ja, in Eclipse kann man auch branchen, versionieren, deployen - dank CVS-, SVN-Plugin und integrierter ant-Unterstützung. Man kann sich auch .jardesc-Dateien definieren, mit denen man ratz-fatz die Archive projekt- oder kundenspezifisch erstellen kann... Und ob Du es glaubst oder nicht: Man (in diesem Fall ich) ist ziemlich oft im Job dazu gezwungen, auch unter Windows zu arbeiten und da ist es enorm praktisch, dass man mit der gleichen IDE in allen Welten identisch arbeiten kann. Du willst nicht wirklich auf einer Plattform die Fehler beseitigen, die Du auf der anderen Plattform entdeckst (ja, ich weiß: Dein nächster Einwand ist, dass ich einen Windows-Bugfix nicht ohne Weiteres auf andere Plattformen übertragen kann. Da verlasse ich mich dann einfach mal darauf, dass ich Java hinreichend gut kenne und ein wenig programmieren kann - und testen muss ich eh jede Plattform). Meine Programme müssen nämlich fast immer sowohl unter Win* als auch unter Solaris und Linux laufen.
@BlueJay: Zu Deinem Einwand betr. "COM-Port, C++ und Eclipse" - ich kann mich nicht erinnern, dass zerix oder ich Eclipse je als allein seligmachende Alternative dargestellt hätten. Wir haben über Java geschrieben (nicht C++!) und ich zumindest habe von hardwarenaher Programmierung nicht allzuviel Ahnung. Wenn es um C(++) geht, dann habe ich bisher andere Tools benutzt, nicht Eclipse, allerdings laufen solche Projekte bei mir eher unter Windows und VS ab.
Moin,
Ich meinte das umgekehrt, d.h. Bewerber waren ansich programmiertechnisch akzeptabel, aber nur in der von ihnen gewohnte IDE, wie gesagt inklusive Fälle, wo jemand nicht mal "make" kannte/konnte.
Genau das meinte ich: Den Umgang mit Tools kann man lernen, und Erfahrung mit "make" wird jemand, der bisher nur unter Windows entwickelt hat, wohl eher nicht haben (es sei denn, er hat sich mal mit nmake befasst). Ich habe meine ersten beruflichen Programmierschritte mit vi, ced-(SINIX) und rand-(TOS) Editor gemacht - jedes neue Entwicklungstool musste ich erst kennenlernen. Keine Firma, in der ich danach gearbeitet habe, hat meine Einstellung davon abhängig gemacht, ob ich die in dieser Firma gebräuchlichen Tools kannte. Es wurde schlicht und einfach davon ausgegangen, dass ich in der Lage wäre, das zu lernen (bisher hats noch immer funktioniert ;-).
Logging zur Fehlersuche setzt natürlich vorraus, dass der Entwickler weiß was der Code tun sollte und welche Eigenschaften als Problemquelle in Frage kommen. Problemanalyse und so.
Denkst Du, beim Debuggen verteile ich Breakpoints nach dem Gießkannenprinzip? Ich setze die Breakpoints (gestützt auf die Daten oder das Log - ja, ich benutze auch Logs!) kurz vor die Stelle, an der ich den Fehler vermute und browse dann in aller Ruhe durch alle relevanten Objekte (die ich schön in einem Tree angeboten kriege). Wenn ich nicht weiss, was im Code passiert, dann sind weder Logging noch Debugging sonderlich hilfreich und effektiv. Nur ist manchmal Code eben etwas komplexer und eine Zeile Java kann etliche Objekte / Methoden / Properties enthalten, die als Ursache in Frage kommen.
Erstens ist gutes Logging verteilt, d.h. geht zum Beispiel in verschiedene Dateien.
Zweitens ist entsprechend formatierter Logoutput sehr einfach maschinell zu untersuchen, u.a. mit grep oder ähnlichen Tools.
Hm, lass mal den Ablauf nachspielen: Ich habe also n verschiedene Logs (würde ich persönlich eher nie machen, dann ist nämlich die zeitliche Korrelation überhaupt nicht mehr - oder nur sehr aufwändig - nachvollziehbar). Also mache ich zuerst mal ein "grep -li 'Suchbegriff' LogFiles*", um herauszufinden, in welchen Logdateien meine relevante Info steckt. Dann will ich natürlich wissen, was da geloggt wurde - und ich brauche auch noch ein paar Infos, was davor und danach passierte. Also "grep -in -B 10 -A 10 'Suchbegriff' relevanteLogDatei". Oh - interessant wird es offenbar doch schon ein paar Zeilen früher: "grep -in -B 20 -A 10 'Suchbegriff' relevanteLogDatei". Mist - der interessante Teil der Logdatei ist oben aus dem Fenster verschwunden: "grep -in -B 20 -A 10 'Suchbegriff' relevanteLogDatei | less". Ah - da ist was faul in Zeile XXX. Aber da wird ein Objekt benutzt, wo die Debug-Info zur Initialisierung offenbar in einer anderen Log-Datei steckt: also wieder mit "grep -li 'neuerSuchbegriff' LogFiles*" loslegen. *Grr* - das Ding wird ja 200x initialisiert - muss man mal nach dem Zeitstempel suchen. Aber wie lange hat das gedauert? Reichen 10 Sekunden abwärts? Suchen wir mal ungefähr nach der Zeit (im Raster +/- 1 Minute) - verdammt, das war genau um die volle Stunde rum ... - falls Du mal Hilfe für solche RegEx brauchst - frag im Script-Forum nach ;-) Aber jammer dann nicht rum, dass Du den Fehler nicht so schnell findest.
Ähm - die -A und -B Option kennt nur GNU-grep, unter Solaris bist Du aufgeschmissen. Und ohne gute Kenntnis von regulären Ausdrücken bist Du auch ziemlich schnell erschossen.
Und noch was: Richtig lustig wird es dann, wenn die beteiligten Systeme alle unterschiedliche Logformate benutzen und in unterschiedlichen Loglevels fahren: Apache -> access_log, error_log; JBoss-Servlets -> Log4J; AnwendungX -> Log4J (aber Zeitstempel in UTC statt GMT); AnwendungY -> proprietaryLog (andere Reihenfolge, anderes Format z. B. der Zeitstempel), ServiceZ -> syslog ... - dann bist Du froh, wenn Du Deine Anwendung debuggen kannst und wenigstens siehst, wie die Requests / Responses aussehen.
Ach ja: Bei vielen Kunden ist eine Code-Änderung (z. B. neuer Log-Eintrag) in der Regel an einen formalen Freigabeprozess gebunden (IT-Test -> Fachbereichstest -> QS -> Referenzsystem -> Prod, beliebig komplexer auslegbar), das dauert mitunter Wochen. Und ein Loglevel "DEBUG" kommt aus naheliegenden Gründen für Prod-Systeme beim Kunden eh nicht in Frage. Wo kriegst Du denn dann die Infos her? Mit Daten vom Prod-System hast Du wenigstens eine Chance, mit dem Warten auf aussagefähige Logs vom Prod-System nicht.
Ich habe ein extrem überspitztes Szenario aufgebaut. Nur - das ist kein theoretischer Fall, ich habe das neulich bei einem Kunden machen müssen, bei dem ich die Loggings verschiedener beteiligter (und hochbeschäftigter) Systeme nach zeitlich passenden Auffälligkeiten abgrasen musste. Da kamen etliche GB an Logs zusammen. Dankenswerterweise hat jedes System nur 1 Logdatei geschrieben, trotzdem war es die Strafe für jemanden, der Vater + Mutter erschlagen hat ;-) Ich bilde mir übrigens ein, dass ich recht gut mit den Unix-Kommandozeilentools umgehen kann, nutze aber trotzdem jede Chance, wenn ich ein System live debuggen kann. Das geht einfach schneller.
Das schau ich mir. Wie entscheidest du, zu welchem Zeitpunkt du den normalen Lauf des Programms unterbrichst, um dir Werte anzusehen?
Wenn der Fehler bemerkbar wird und hoffen, dass inzwischen keine weitere Zustandsänderung vorgenommen wurde?
Einen Breakpoint setzten und eine Stunde lang (oder wie lange auch immer es dauert bis der Problem auftritt, Tage vielleicht) im Debugger "continue" klicken?
Siehe oben. Und so ganz nebenbei: Im Eclipse-Debugger (wie in vielen anderen auch) kannst Du mit "Step over" über offensichtlich irrelevante Methodenaufrufe hinweghüpfen oder per "Resume" zum nächsten (auch während der Laufzeit änderbaren) Breakpoint eilen.
Jan
Toll, und wie lange muss ich dann probieren (es gibt ja nicht nur Hashtable, wo es im Zweifelsfall 1 Buchstabe ist, den man falsch schreibt)?
Das kommt darauf an, wie gut du die Sprache beherrschst, zumindest nach der Definition in *alten* Zeiten. :)
Falls Du Typisieren von Collections bei Java-5.0-Kompatibilität meinst - ja, da gibt es Mecker, wenn ich nicht typisiere oder Errors, wenn ich falsche Typen zuweise - gleich, nicht erst zur Laufzeit.
Dieser Fehler wird auch schon vom Compiler gemeldet.
Mit den "Häkchen" wollte ich eigentlich nur checken, ob Eclipse das hinkriegt, deshalb bin ich nicht genau geworden.
Dateien nicht gefunden hast ... <hüstel> - Du kennst find (falls Du damit nicht klarkommst
so gesehen ist eigentlich find damit nicht klargekommen, weil das Zeuch noch nicht in seiner "Datenbank" war. Sorry, das gentoo ist so ein altes System, der baut die Tabelle nur bei Gelegenheit auf, und die hatte er wohl noch nicht.
Und ein search auf die ganze Platte loslaufen zu lassen ist hier und heutzutage Zeitverschwendung.
- ich beantworte gerne Deine Fragen im Script-Forum ;-)? Ganz nebenbei - in Eclipse Rechtsklick auf die Datei -> "Properties" und schwupps steht da der Pfad relativ zum Workspace und die Location als absoluter Pfad.
sofern nicht ausgegraut...
Ich nehme es Dir und anda_skoa ja ab, dass Ihr lieber mit Editor + javac + [make|ant] + System.out (warum eigentlich nicht mit sed, awk, grep & Co.?
sed auf Java-Variableninhalte loslassen? Das musst du mir mal näher erklären!:) Ich werde das Script-Forum danach checken.
Es ist nur einfach so, wenn ich irgendwo hinkomme, und da ist wieder eine IDE auf der Pladde, die ich noch nicht kenne, stehe ich wie ein Ochse vor'm Berg. Und für ein bisschen programmieren und Optimieren werde ich mir nicht noch eine IDE mit allen ihren versionsabhängigen Tücken reinziehen.
Entweder pariert sie schon beim ersten-, aber bestimmt beim zweitenmal in punkto editieren, compilieren, (linken,) laufenlassen, oder das war's.
@BlueJay: Zu Deinem Einwand betr. "COM-Port, C++ und Eclipse" - ich kann mich nicht erinnern, dass zerix oder ich Eclipse je als allein seligmachende Alternative dargestellt hätten.
In diesem Thread ging es nicht nur um Java, sieh dir die Beschreibung zu diesem Brett noch mal an. Und Jor sprach auch von Javascript und php. Der Krusader-Editor wird mit allem fertig.
zerix' Zitat passte wie die Faust aufs Auge, und so eine Steilvorlage darf man sich nicht entgehen lassen :D
COM-Ports ansteuern ist bei mir auch dunkle Vergangenheit, hab's mal in C und Pascal gemacht, zum Glück hatte ich bei C eine Beschreibung der Bibliothekenheader, dann klappt das nämlich auch mit Wordstar und Konsorten, sogar auf total verschiedenen Betriebssystemen.
A propos alte Zeiten:
Dein TOS ist doch nicht etwa Tramiels Operating System?
Dabei lernte ich dann auch, einer IDE grundsätzlich zu misstrauen und denke heute an alte Zeiten, wenn ich solche Beiträge sehe wie "In der IDE lief alles perfekt, ohne geht gar nichts mehr". (Ja, ich habe damals herausbekommen, wie die IDE mich veräppelt hat!)
so long,
BlueJay
Kann Windows immer noch kein Multitasking? :p
Also ich weiß ja nicht, ich kann leider nur ein Programm auf einmal bedienen. Ich müsste zum Beispiel ständig zwischen Konsole und Editor wechseln. So brauche ich das nicht.
Also man kann Breakpoints entfernen, muss es aber nicht. Kostet auch keine Performance. Ich kann aber, wenn es sein muss alle Breakpoints mit einem klick entfernen. Es wäre auch egal, wenn ich einen übersehe (was nicht passieren kann). Das macht dem Code nichts, da ich ja nichts am Code verändert habe.
Wie das bei dem c++-Thema aussieht, kann ich dir nicht sagen.
Kannst du denn mit deinem Editor eine Datenbank anschauen und bearbeiten? Oder brauchst du dafür schon wieder extra Software?:-)
MFG
zEriX
In diesem Thread ging es nicht nur um Java, sieh dir die Beschreibung zu diesem Brett noch mal an. Und Jor sprach auch von Javascript und php. Der Krusader-Editor wird mit allem fertig.
Es kann gut sein, dass man mit dem CDT-Plugin für eclipse das mit dem COM-Ports hinbekommt, aber ich kann dazu nichts sagen, da ich es nicht weiß. Ich kann mir auch nicht vorstellen warum es nicht gehen sollte, weil man ja lediglich nur den Code bearbeitet.
JavaScript und PHP kann man mit eclipse auch schreiben, auch mit dem gleichen Komfort wie bei Java. Auch für XML, XSD und XSLT gibt es schöne Plugins die einem viel Arbeit abnehmen.
MFG
zEriX
hallo @all, hallo zerix,
in der Zweischenzeit habe ich Eclipse installiert und und nutze es zur JavaScript und PHP (inkl. HTMl natürlich) zu proggen.
Bin damit ziemlich zufrieden, allerdings gibt es auch Verbesserungspotential, wenn ich an meine Weaverslave denke (Image einbinden z. B.)[oder ich habe noch nicht die richitgen Schalter gefunden]. Aber im allgemeinen war der Umstieg gut und passend. :)
...so gesehen ist eigentlich find damit nicht klargekommen, weil das Zeuch noch nicht in seiner "Datenbank" war. Sorry, das gentoo ist so ein altes System, der baut die Tabelle nur bei Gelegenheit auf, und die hatte er wohl noch nicht.
Und ein search auf die ganze Platte loslaufen zu lassen ist hier und heutzutage Zeitverschwendung.
Nein, da verwechselst Du was. find geht immer auf die Platte, locate nutzt eine Datenbank. Wenn ich eine Datei wirklich brauche, dann suche ich auch. Das ist für mich dann keine Zeitverschwendung ;-)
A propos alte Zeiten:
Dein TOS ist doch nicht etwa Tramiels Operating System?
Targon Operating System (Unix-System von Nixdorf - es ruhe in Frieden ;-)
Jan
Also ich weiß ja nicht, ich kann leider nur ein Programm auf einmal bedienen. Ich müsste zum Beispiel ständig zwischen Konsole und Editor wechseln. So brauche ich das nicht.
Ist doch nur 1 Klick entfernt!
Kannst du denn mit deinem Editor eine Datenbank anschauen und bearbeiten? Oder brauchst du dafür schon wieder extra Software?:-)
Wenn's denn sein muss, und wenn die Änderungen nur Texte und nicht die Struktur betrifft, oder wenn es eine (index-)sequenzielle ist...
Wenn's eine richtig fette (relationale) Datenbank ist, nehme ich sowieso lieber ein Datenbank-Manager, da richtet man wenigstens kein ungewolltes Unheil an.
@jan:
eclipse verweigert mir die Zusammenarbeit (gentoo-64, Sun JDK 1.6). Der patch greift nicht, auch wenn ich ihm das JDK-Directory direkt unterschiebe. (vm ExitCode 13, Schuldiger ist ein equinoxe-Launcher).
Eclipse ist lokal in ein frisches Directory installiert.
Das gentoo ist ferngewartet, und man muss immer damit rechnen, dass als root nachinstallierte Bibliotheken eines nicht allzu fernen Tages veschwinden.
so long,
BlueJay
Powered by vBulletin® Version 4.2.5 Copyright ©2024 Adduco Digital e.K. und vBulletin Solutions, Inc. Alle Rechte vorbehalten.