Was braucht man alles fürs erfolgreiche Programmieren?

Wer richtig Programmieren will, der muss einige Dinge beachten, damit alles erfolgreich läuft. Vor allem wer professionell programmiert weiß, dass es immer wieder Kleinigkeiten gibt, mit denen man den Erfolg noch steigern kann. Doch was genau braucht man alles, um beim Programmieren erfolgreich zu sein und Programme zu erschaffen, die mehr können als Zahlen addieren?

Zunächst einmal braucht man eine gute Kenntnis über eine oder mehrere Programmiersprachen. In einer Programmiersprache sollte man sich spezialisieren. Das Wissen über mehrere Sprachen vereinfacht es zudem Verknüpfungen und Schnittstellen zu schaffen. Beispielsweise kann man mit HTML zwar schon einiges ausrichten, aber erst mit CSS und Java kann man eine Webseite optimal gestalten.

Für Programmieren an sich braucht es keine sonderlich gute Hardware. Ein einfacher Office-PC reicht dabei in der Regel schon aus, um die Codezeilen zu füllen. Erst wenn es darum geht, das Programm auch auszuführen, kann es sein, dass man einen besseren PC braucht. Das hängt aber ganz klar von der Art des Programms ab. Wer Spiele programmiert und designt, der wird einen recht guten PC brauchen. Neben dem PC braucht es natürlich auch einen Monitor. Optimal sind auch zwei Monitore, zwischen denen man wechseln kann. Wer zusätzlich auch Games spielt, dem sei eine etwas bessere Hardware für den PC empfohlen.

Wer lange programmiert, der muss natürlich auch einen gewissen Komfort genießen. Auf einer schlechten Sitzgelegenheit wird man langfristig über Rückenschmerzen klagen. Dem kann man mit einem ordentlichen Stuhl vorbeugen. Es gibt einige Hersteller, die sich auf Sitzgelegenheiten für den Büro- und Gamingtisch spezialisiert haben. Diese Stühle können mit guter und angepasster Ergonomie punkten und sind neben tollem Design auch sehr komfortabel. Es gibt viele Hersteller solcher Stühle und einer dieser Hersteller ist Noblechairs, von denen ich selber einen Stuhl gekauft habe und absolut überzeugt bin. Ein guter Stuhl ist eine gute Voraussetzung für erfolgreiches Arbeiten vor dem Bildschirm.

Wenn man nun alles fürs Setup hat, dann kann es an das eigentliche Werk gehen. Man braucht viel Geduld und Durchhaltevermögen, um auch bei langen Programmen nicht schnell die Motivation und die Lust zu verlieren. Denn es wird immer wieder kleine Fehler geben, die zu beheben sein werden. Mit der richtigen Einstellung, etwas Planung und Grips kann das Programmieren aber zu einem richtigen Erfolg werden. Man sollte dabei klein anfangen und sich hocharbeiten. Denn vor allem die Erfahrung schafft gute Ergebnisse und je mehr man von ihnen sammelt, desto besser wird das Resultat.

Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar

Die kleinen Lästigkeiten des Programmierens

Programmieren ist eine feine Sache, denn man kann Dinge erschaffen, ohne dass man sie kaufen muss. Eigenständig ein Programm zu schreiben ist zwar eine aufwendige Angelegenheit, die auch viel Zeit in Anspruch nimmt, doch das eigene Programm ist immer etwas Besonderes. Doch neben dem Ärgernis von möglichen Programmfehlern oder dem streikenden Computer, gibt es auch andere Probleme, die nicht direkt mit der digitalen Schöpfung zusammenhängen.

So kann das lange Sitzen vor dem Bildschirm schlecht für den Rücken sein. Vor allem, wer über eine schlechte Sitzgelegenheit verfügt, der wird nach einiger Zeit Rückenschmerzen spüren. Oft ist es dabei ein leichtes Stechen, welches man verspürt. Aber Rückenschmerzen können sich durch vielerlei Arten äußern. Doch auch von Nackenschmerzen wird man nicht verschont, wenn man zu lange am PC sitzt. Sinnvoll kann es dabei sein, zwischendurch aufzustehen und sich etwas zu Strecken oder zu Dehnen.

Wesentlich sinnvoller ist es aber, sich einen besseren Stuhl zu kaufen. Ein hochwertiger Bürostuhl kann da Abhilfe schaffen. Man sollte auf eine gute Ergonomie des Stuhls achten. Gute Bürostühle verfügen oft auch über ein Polster für den Nacken, um etwaigen Nackenschmerzen vorzubeugen. Alles in allem sollte der Stuhl sehr gemütlich sein und einen guten Komfort bieten. Wer neben dem Programmieren auch noch gerne PC Games spielt, der kann auch auf einen Gamingstuhl zurückgreifen. Diese sind auch von diversen Gaming Wettbewerben bekannt und verfügen über einen sehr hohen Komfort.

Doch nicht nur der Rücken wird durch das viele Sitzen beansprucht, sondern auch die Augen. Das künstliche Licht der Bildschirme kann die Augen auf Dauer belasten und sogar negativ beeinflussen. Um dem vorzubeugen, sollte der Bildschirm weit vom Auge entfernt sein. Denn das Auge passt sich sonst zu sehr an die Nähe an und die Folge ist Kurzsichtigkeit. Aber auch wegen des hohen Blauanteils vieler moderner Bildschirme kann das Auge belastet werden. Eine weitere Folge davon ist das schlechte Einschlafen durch zu hohen Blauanteil. Aus diesem Grund verfügen viele moderne Geräte über einen Blaulichtfiler oder Nachtmodus. Ab einer bestimmten Uhrzeit wird ein Teil des blauen Lichts herausgefiltert. Intelligente Programme passen den Anteil dabei sogar an die Umgebungsbeleuchtung und die Uhrzeit an. Wer die Möglichkeit hat, der sollte auch darauf zurückgreifen.

Es gibt viele kleine Probleme außerhalb des eigentlichen Programmierens. Aber wie beim Programmieren auch kann man die Fehler finden und sie beheben. Das Endresultat ist dabei gut und stellt zufrieden. Für alle Probleme gibt es eben eine Lösung, auch wenn es den Stuhl oder den Bildschirm betrifft.

Veröffentlicht unter Uncategorized | Hinterlasse einen Kommentar

JTable HeaderRenderer mit System LookAndFeel (PLAF)

Ach, es ist schon ein Kreuz mit Plattform-Designs. Insbesondere mit Swing. Will man für Tabellen die Spaltenköpfe etwas optisch anpassen, aber zugleich das System-Design nicht verlieren, muss man ein paar kleine Tricks anwenden, die gar nicht mal so gut dokumentiert sind.

Hier mal ein Beispiel wie es für Windows 7 aussieht, wenn man des Standard-Renderer nutzt:

So sieht es aus, wenn man nach den üblichen Rezepten vorgeht und einen eigenen Renderer verwendet:

Sogar wenn man den original installierten Renderer (der durch das PLAF gesetzt wurde) aus dem JTableHeader nimmt und diesen ändert, wird man feststellen, dass die Tabellenköpfe trotzdem wie aus den 90′er Jahren aussehen. Ungefähr so wie alte Sportschuhe von den Fußballern aus derzeit. So etwas wäre aber sicherlich mit einem Fußballschuh Test nicht passiert.

Der eigentliche Grund ist, dass man i.d.R. es verpasst UI-Änderungen des UIManager an den Header-Renderer weiterzuleiten.

Generell ist es gut dem eigenen Renderer im Constructor den als Standard installierten Renderer mitzugeben, der von Java Swing sowieso gesetzt wird:

public class DBTableHeaderRenderer 
            extends DefaultTableCellRenderer 
            implements TableCellRenderer {
private final TableCellRenderer headerRendererUI;
public DBTableHeaderRenderer(TableCellRenderer headerRenderer) {
  this.headerRendererUI = headerRenderer;
}

Nun holt man in der getTableCellRendererComponent Methode aus dem headerRendererUI die Renderer-Komponente, die man anpassen möchte:

@Override
 public Component getTableCellRendererComponent(
   JTable table, Object value,
   boolean isSelected, boolean hasFocus, int row, int column) 
 {
   Component resUI = headerRendererUI
                    .getTableCellRendererComponent (table, value,
                                  isSelected, hasFocus, 
                                  row, column);
  if (resUI instanceof JLabel) {
    JLabel label = (JLabel) resUI;

Wenn man das debugged, stellt man fest, dass in resUI tatsächlich die UI-Komponente aus dem System-PLAF ist, aber trotzdem sieht es aus, als würden die Header wie in Windows 2000 gezeichnet.

Änderungen beim PLAF werden allen Komponenten via updateUI mitgeteilt. Im unseren Renderer können wir die Methode überschreiben und die Benachrichtigung an headerRendererUI delegieren:

 @Override
 public void updateUI() {
   TableCellRenderer tcr = headerRendererUI;
   if (tcr instanceof JComponent) {
     ((JComponent) tcr).updateUI();
   } else {
     super.updateUI();
   }
 }

Obwohl dies das exakt richtige Vorgehen ist, wird man beim nächsten Test sich die Haare raufen. Der Renderer sieht immer noch altbacken aus.

Wir müssen unseren Renderer noch mit einem Marker-Interface ausstatten, damit auch wirklich updateUI aufgerufen wird. Also muss die Klassen-Deklaration ergänzt werden:

public class DBTableHeaderRenderer 
       extends DefaultTableCellRenderer 
       implements TableCellRenderer, javax.swing.plaf.UIResource {

Mit dem UIRessource-Interface ist der Renderer nun endlich optisch auf Höhe der Zeit und man kann das JLabel nun nach eigenen Wünschen anpassen.

 

Veröffentlicht unter Uncategorized | Verschlagwortet mit , , , , | Hinterlasse einen Kommentar

JavaFXDev: NetBeans Platform with JavaFX 2.0ea

Hi!

Alan O’Leary shows in his blog a WebView integration in Swing. It is a not good documented feature, how to integrate JavaFX 2.0 controls into a swing application. But an integration is a main goal for the JavaFX 2.0 release.

As an enthusiastic NetBeans Platform/RCP developer and JavaFX partner, I work since two days to marriage JavaFX 2.0 and a NetBeans Platform Application. And yes, it works 🙂

I’ve created a maven based platform application with a special starter Main.class. I need to launch the JavaFX toolkit system before any other module bootstrapping. The solution here is based on the early access release through the JavaFX partner program. This “best practice” may change significantly between now and the final version. However, I’ll show only a concept, not compilable code.

The solution behind the bootstrapping a NetBeans Platform is based on a FAQ by Tom Wheeler. My Main.class is a JavaFX Application class – I need this Application instance to get rid of from invoke exceptions. The created Stage object by the Launcher can be ignored.

The Main class is in a standard Java archive. This JAR file and all the JavaFX files must be in the platform/core folder.

At runtime all the core-Libs are available to the whole NetBeans Platform modules (and plugins). For the compiler I need a special dependency to the runtime:

The system path depends on your project structure.

Now I can access all the JavaFX classes in a NetBeans module.

Please note, any scene construction needs to be build up in the JavaFX event queue thread. This is not the EventDispatcher-Thread from Swing!

My favorite call to jump in the JavaFX event thread is: Toolkit.getDefault().defer (Runnable) javafx.application.Platform.runLater (Runnable). But the Toolkit class is in a com.* package. IMHO in the future we get an official way to do this.

The creation of a WebView component is pretty similar to the sample from Alan. But I don’t need a stage object:

I’ve added some useful listeners. Please aware the switches between different threads (Swing and JavaFX).

The result is a beautiful NetBeans Platform application with an embedded JavaFX 2.0 WebView:

PS.: I like the Twitter message from Dean Riverson: “Ok, I call a moratorium on rotating and reflecting WebView…” (origin). –

I have to write 100 times:

Veröffentlicht unter Uncategorized | Verschlagwortet mit , , | Hinterlasse einen Kommentar