Javasasszony blogja

Szoftverfejlesztéssel töltött 16 évemben többször szembesültem azzal a ténnyel, hogy egyes programozók elfelejtik megtervezni a kódot. Vagy nem is akarják, mert ahogy Webisztános HH egyszer mondta:

szerencsere ma mar nem kell eldontenunk programozas megkezdese elott h egeszen pontosan mire is fogjuk hasznalni az adott szoftvert a jovoben. [...] a folyamatos, interativ fejlesztes korat eljuk. nem a dobozos szoftvereket.

http://geeklany.wpress.hu/2010/04/behalozott-fozocskezes/

Kis csapatoknál nem is annyira életképtelen ötlet: nagyjából tudjuk, hogy mit akarunk, összedobjuk a kódot és menet közben végezzük el a refactoringot.

Nagyobb csapatoknál gyakrabban fordul elő a "nem tudja a jobb kéz, mit csinál a bal" effektus. Emberek jönnek, mennek, kevesen maradnak, ha maradnak egyáltalán, akik átlátják a kódot. A tapasztalati szint is széles skálán mozog. Refactoringra csak akkor van lehetőség, ha azt megtervezzük és a projektfejlesztési menetbe beillesztjük.

Konkrétan a mi projektünkben pár alkalommal a táblázatban megjelentetett adatokat CSV file-ba kell exportálni. Nehezítésül a látható oszlopok listája és az exportálandó oszlopok listája nem fedi egymást teljesen.

Gyakorlott programozó ebben egy általános osztály megvalósításának lehetőségét látja, ahol egyfelől megadom a szűretlen adatokat, másfelől az exportálandó mezők listáját, majd ezeket egy egységes kódban (filenév választással stb.) exportálom.

Kevésbé gyakorlott programozó megcsinálja egyszer, az adott feladatra tökéletesen elkészítve, majd fél évvel később a másik, szintén kevésbé gyakorlott programozó lemásolja, átalakítja az új (változott) követelményeknek megfelelően.

Végeredményben lesz 5 Java osztályunk, ami ugyanazt csinálja, csak mindig kicsit másképp. A konszolidációs javaslatunkra tett válasz pedig kimerül a "mindegyik egy kicsit más, nem lehet közös nevezőre hozni" válaszban.

Hogyan másképp?

Ennek elkerülésére találták ki a különböző rendszerszervezéssel foglalkozó könyvek, hogy a program egészének tervezése több lépcsőben zajlik.

1. Funkcionális követelmény
2. Architektúra
3. Kódterv
4. Kód

Minden szinten van egy személy, aki az adott szinten átlátja a komplett rendszert.

Optimális esetben nem fordul elő az, hogy két funkcionális követelmény ugyanazt a részt módosítja egy releaseben kétféleképpen. Ha mégis, akkor ennek legkésőbb az architektúra szintjén ki kell derülnie.

Az architekt (avagy építész a Mátrix filmek kedvelőinek) nagyvonalúan foglalkozik a technikai megvalósítással. Tudja, hogy az adott követelményeket mely modul(ok)ban kell megvalósítani, milyen jellegű fejlesztéseket kell végrehajtani és ehhez milyen - esetleges - harmadik cég által készített frameworköt kell használni.

Azt is illik tudnia, ha valamelyik feature-t már megvalósították és a dokumentumban javasolja (igényli) az egységesítést.

A kódtervet (pl. UML) már a fejlesztői szinten készítik el. Legkésőbb itt kell eldönteni, hogy egy meglévő funkciót kell-e általánosítani, illetve mennyire kell általánossá tenni egy új funkciót. Néha semennyire - nem kell túllihegni az egész témát.

A kód szinte szolgai megvalósítása a kódtervnek, ámbár ez sem igaz, hiszen a kódernek tisztában kell lennie a nyelv lehetőségeivel, határaival. Egy művész itt tudja magát igazán kiélni és készít agyonoptimalizált ámde olvashatatlan, avagy gyönyörűen olvasható kódot.

Az egyes szintek között természetesen elengedhetetlen a kölcsönös párbeszéd, mert anélkül fejetlen fejsze elsüllyedt nyele az egész.

Még ha az esetek 90%-ban (amikor leülök és ontom ki magamból a forrást) jobban boldogulok az Eclipse fejlesztő felületével, ott az a 10%, amikor más kódjában kell turkászni, amikor bogarászunk (aka bugfix), tehát amikor át akarjuk látni, hogy mi az isten történik a programban, akkor nagyon kéne egy ilyen. Akár Eclipse pluginként, akár standalone alkalmazásként, de nyilván inkább pluginként.

Akit érdekel, az jelentkezhet béta teszternek.

via ignore the code

via geek & poke

Forrás: Cardonizer

Az Eclipse nagyszerű súgó felülettel rendelkezik, amit érdemes az RCP kliensünkbe beépíteni, ha nem magunk akarjuk leprogramozni.

A beépítése három részből áll:

1) Plugin függőségek felvétele

2) Help menü

3) Help plugin elkészítése

Plugin függőség

Abban a pluginben, ahol a Help menüt el akarjuk helyezni, az alábbi függőségeket (plugin dependency a plugin.xml-ben) kell felvenni:

• javax.servlet
• javax.servlet.jsp
• org.apache.commons.el
• org.apache.commons.logging
• org.apache.jasper
• org.apache.lucene
• org.apache.lucene.analysis
• org.eclipse.core.variables
• org.eclipse.equinox.http.jetty
• org.eclipse.equinox.http.registry
• org.eclipse.equinox.http.servlet
• org.eclipse.equinox.jsp.jasper
• org.eclipse.equinox.jsp.jasper.registry
• org.eclipse.help.appserver
• org.eclipse.help.base
• org.eclipse.help.ui
• org.eclipse.help.webapp
• org.eclipse.osgi.services
• org.motbay.jetty

Help Menü

A ApplicationActionBarAdvisor osztályba helyezzük el az alábbi, NEW-val jelölt kódokat:

public class ApplicationActionBarAdvisor extends ActionBarAdvisor {

    // Actions - important to allocate these only in makeActions, and then use them
    // in the fill methods.  This ensures that the actions aren't recreated
    // when fillActionBars is called with FILL_PROXY.
    private IWorkbenchAction exitAction;
    private IWorkbenchAction aboutAction;
    private IWorkbenchAction showHelpAction; // NEW
    private IWorkbenchAction searchHelpAction; // NEW
    private IWorkbenchAction dynamicHelpAction; // NEW

protected void makeActions(final IWorkbenchWindow window) {
    // Creates the actions and registers them.
    // Registering is needed to ensure that key bindings work.
    // The corresponding commands keybindings are defined in the plugin.xml file.
    // Registering also provides automatic disposal of the actions when
    // the window is closed.

    exitAction = ActionFactory.QUIT.create(window);
    register(exitAction);

    aboutAction = ActionFactory.ABOUT.create(window);
    register(aboutAction);

    showHelpAction = ActionFactory.HELP_CONTENTS.create(window); // NEW
    register(showHelpAction); // NEW

    searchHelpAction = ActionFactory.HELP_SEARCH.create(window); // NEW
    register(searchHelpAction); // NEW

    dynamicHelpAction = ActionFactory.DYNAMIC_HELP.create(window); // NEW
    register(dynamicHelpAction); // NEW

protected void fillMenuBar(IMenuManager menuBar) {
   MenuManager fileMenu = new MenuManager("&File", IWorkbenchActionConstants.M_FILE);
   MenuManager helpMenu = new MenuManager("&Help", IWorkbenchActionConstants.M_HELP);

   menuBar.add(fileMenu);
   // Add a group marker indicating where action set menus will appear.
   menuBar.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
   menuBar.add(helpMenu);

   // File
   // (...)

   // Help
   helpMenu.add(aboutAction);
   helpMenu.add(showHelpAction); // NEW
   helpMenu.add(searchHelpAction); // NEW
   helpMenu.add(dynamicHelpAction); // NEW

Forrás: Eclispe Corner

Help plugin

1. Hozz létre egy új plugin project-et.
2. A template oldalról válaszd ki a "Plug-in with sample help content"-et
3. Az RCP Application pluginban (vagy a hozzá tartozó product/feature file-ban) hozd létre a help plugintól való függőséget.

* A fenti pluginek és források Eclipse 3.3 használatára vonatkozik.

Vannak esetek, amikor az ügyfél megszabja, hogy milyen verziójú Java Runtime van engedélyezve a céges környezetben. Ebben az esetben hiába tudjuk, hogy a (leg)újabb Java verzió sokkal jobb lenne a feladat elvégzésére, alkalmazkodni kell a munkaadóhoz.

Néha azonban becsúszik 1-1 gikszer, főleg ha magasabb verziójú SDK-t használva a javac paraméterezésével akarjuk kompatibilissé tenni programunkat.

Ilyenkor kapjuk futtatásnál (rögtön a futás elején) a fenti hibaüzenetet, a végén a problémás verzió számmal.

Ellenőrzéshez valamilyen HexaEditorban (de akár a Total Commander viewer-je is meg tudja mutatni Hexa-ban a file tartalmát) nézzük meg a class file-okat. Jar file-onként elég egyet.

Figyelnünk a nyolcadik byte-ot kell (az egyszerűség kedvéért az első nyolc byte-ot mutatom meg az alábbiakban):

0x CA FE BA BE 00 00 00 2D = Java 1.1 (major 45)
0x CA FE BA BE 00 00 00 2E = Java 1.2 (major 46)
0x CA FE BA BE 00 00 00 2F = Java 1.3 (major 47)
0x CA FE BA BE 00 00 00 30 = Java 1.4 (major 48)
0x CA FE BA BE 00 00 00 31 = Java 1.5 (major 49)
0x CA FE BA BE 00 00 00 32 = Java 1.6 (major 50)

Amelyik Java archívumban az engedélyezettől nagyobb verziót találunk, azt kell újrafordítani, vagy ha ez nem lehetséges, akkor egy korábbi verziót beszerezni, esetleg a céget az újabb verziójú Java engedélyezésére rávenni.

 

 

Mit csinálsz, ha OutOfMemoryError-ral találkozol a Java programodban? Csak egyszerűen felemeled a rendelkezésre álló memória méretét vagy vadászatra indulsz?

Én elsőként felderítőket küldök ki, méghozzá az alábbi Threadet indítom el elsőként a programban. 

private static final SimpleDateFormat df =
new SimpleDateFormat("yyyy.MM.dd. HH:mm.ss"); 

private static final NumberFormat nf = NumberFormat.getInstance();
private static final Runtime r = Runtime.getRuntime();

public static final void installdebug() {
new Thread(new Runnable() {

public void run() {
while (true) {
try {
long freeMemory = r.freeMemory();
// long maxMemory = r.maxMemory();
long totalMemory = r.totalMemory();
long busyMemory = totalMemory - freeMemory;
// String smax = nf.format(maxMemory);
String stotal = nf.format(totalMemory);
String sbusy =  nf.format(busyMemory);
String sfree = nf.format(freeMemory);
System.out.print(df.format(new Date()));
System.out.println(" | total: "+stotal+" | busy: "+sbusy+ " | free: "+sfree); 

try {
XCsirip.status.setMem(sbusy);
} catch (NullPointerException ex)  {
}
// smax = null;
stotal = null;
sbusy = null;
sfree = null;
r.gc();
Thread.sleep(10000);  // sleep 10 sec
} catch (InterruptedException e) {
}
}
}
}).start();
}


Futás közben folyamatosan figyelem az értékeket. A két leggyakoribb oka a memória teljes felhasználására, ha

• túl sok adatot kell kezelnünk egyszerre
• az adatok "eldobása" után a GC nem takarítja ki a memóriát.

Túl sok adat

Tényleg muszáj ennyi adatot egyszerre a memóriában tartani? Legtöbbször nincs szükség minden adatot egyszerre beolvasni. Vannak visszatérő adatok? Kulcsadatok? Akkor használd ezeket ki! Analizáld az adataidat.

A GC sztrájkol

Nincs szakszervezet, nem a szokása. Ha egy objektumot eldobsz, és azt senki más nem használja, akkor az eltűnik a memóriából. Ha mégsem, akkor egy másik objektum is használja. Legtöbbször listenerek használata okoz ilyen problémákat. Az egyik megoldás, ha a WeakRefence-t használod a listenerek létrehozásakor. A másik, ha az objektum felszabadításakor gondoskodsz az objekt-kapcsolatok törléséről is.

Te mit csinálsz, ha kifutsz a memóriából?

 

Szögezzük le, hogy hazudik az, aki azt állítja, hogy a programozáshoz nem kell tudni angolul. Mert igenis kell. A legtöbb osztály és metódus angolul van megadva a legtöbb programnyelvben, így a Javaban is.

Nem kell szakfordítónak lenni a programozáshoz, csupán alapszinten kell tisztában lenni az egyes szavak jelentésével.

A row jelentése például nem végső vagy utolsó, hanem sor. Ebből adódóan a removeRow(row) a "row" változóban megadott sort fogja törölni. De ha nem tudjuk, hogy mit jelent, akkor persze rágódhatunk órákig, hogyan lehet a 100. sort törölni, ha a függvény csak az utolsót engedi...

Programnyelvtől függetlenül minden program lebontható három alapvető műveletre:

1. Szekvencia: azt jelenti, hogy a kiadott parancsok egymás után következnek be. Mindennapi életből példa:
1. Felkelek
2. Megmosakodom
3. Elindulok a munkába stb
2. Iteráció: azaz ismétlődés. Mindennapi életből példa:
1. Hétfőtől péntekig csináld meg a fenti műveleteket
2. Addig vezetheted az autót, amíg van benne benzin
3. Döntés: Ha ... akkor ... egyébként. Mindennapi életből példa:
1. Ha ma csütörtök van, akkor elmegyek edzésre (egyébként nem).

A mindennapi példák segítenek annak megértésében, hogy a programozási nyelveket ne a világtól elrugaszkodott fogalomként kezeljük. Ennek a három alapfogalomnak a segítségével nem csak modellezni tudunk bármit, de emberi nyelvre fordíthatjuk le azt is, amit a program csinál.

Ha nem tudjuk elmondani, hogy mit csinál a program, akkor megérteni se tudjuk azt.

Feladat: asztali (desktop) Twitter kliens megvalósítása JTwitter API-val. A programnak az alábbi specifikációnak kell eleget tennie:

• felhasználói adatok (név, jelszó) beállítása
• kapcsolódás a Twitterhez
• tweetek elküldése (max 140 karakter)
• barátok tweetjeinek kilistázása (max 50) 

A program előzetes látvány- és programterv alapján kell, hogy elkészüljön, valamint a működő programhoz felhasználói leírás szükséges.

A feladat célja, hogy

• a gyakorlati programozás megismerésre kerüljön fontos,
  
• megismerje a tanuló az innovatív munkát (amit már feltaláltak, azt nem kell újra kitalálni)
• közelebb kerüljön a Java programozási nyelvhez.

A feladat nem túl bonyolult, nekem talán 3 órába tellett, mire az első prototípus (ahol a felhasználói adatokat is a GUI-ból lehetett beállítani) elkészült. Figyelembe véve, hogy mennyit haladtunk az első nap, az elkövetkező két hét alatt gond nélkül a végére jutunk.

Ettől persze nem lesz a tanítvány senior java programozó, de bízom benne, hogy közelebb kerül a web2.0 és a java világához.

 

Tanítványt kaptam. 2,5 hetünk van arra, hogy valami érdemlegeset produkáljunk.

Nehezítés: a tanítvány nem beszél javaul és programozni sem tud. Tanult Delphit, de arra jobb nem építeni.

A 2,5 hét nem sok mindenre elég, ha az embernek nulláról kell kezdenie. A cél az, hogy a szakmai gyakorlat végén egy használható - alap szintű - twitter kliens boldog tulajdonosa legyen.

Az első nap programja:

• Alapok.  Java osztály felépítése: konstruktor, metódus, funkció (metódus visszatérő értékkel)
  
• Egyszerű változók (int), osztályváltozók (String). Package-ek.
  
• Programozási alapok: strukturált programozás.
• GUI alapok: Swing, JFrame, JButton, JCheckBox, JLabel. 
  

Fél év programozás tanulás után problémát okozott, hogy

• hova írjuk az új programsorokat (pl egy metódusba és ne a két metódus közötti "üres térbe")
• mit jelent a változó inicializálásnak hiánya
• hogyan kapjuk meg egy funkció visszatérő értékét

A tanítványom azonban tehetségesnek mutatkozik, rövid vesződés, majd a problémára történő rávezetés után többet nem követte el ugyanazt a hibát.

 

 

JTwitter a lehető legegyszerűbb Twitter API, ha a Twitterhez kapcsolódó programok írására adod a fejed. Épp ebben rejlik a nagyszerűsége is. Mindössze két - saját - osztályból áll (Twitter és TwitterException). 

Az osztály annyira egyszerű és magától értetődő, hogy szinte mindennemű magyarázat nélkül el lehet kezdeni használni.

// Twitter objektum létrehozása

Twitter twitter = new Twitter("nev", "jelszo");

// csiripelés
twitter.updateStatus("twitterrel próbálkozom");

Minden, a Twitternél használatos parancsra van megfelelő metódus: follow, unfollow (breakFriendship), DM-ek lekérdezése, követők lekérdezése stb. ránk csak a GUI elkészítésének feladata hárul.

A Twitter API szerverrel JSON formátumban kommunikál. Az így kapott információkat három osztályba (a Twitter-en belül) rendszerezi: Message, Status és User.

A Message-be a közvetlen üzenetek (DM) és a válaszok (reply) tartozik.

A Status a Twitteren megjelenő üzenet (tehát ugyanazt az üzenetet megkaphatjuk Statusként [getPublicTimeLine] és Messageként [getFriendsTimeLine] is, ha nekünk írják, attól függően, hogy mikor és hogyan kérdezzük le).

A User pedig minden, a csiripelővel kapcsolatos információt tartalmazó osztály.

És bármennyire szívesen mesélnék még arról, hogy mennyire egyszerű használni - nem tudok, mert ennél többet nem lehet egy ilyen egyszerű wrapperről beszélni.

Próbáld ki Te is.

 

Miután az IBM elállt a vásárlástól,  a SUN-t 7.4 milliárd dollárért felvásárolta az Oracle. Ezzel az Oracle tulajdonába került  a Solaris és a Java az elsősorban webes fejlesztéseknél elterjedt adatbázisszerver, a MySQL is.

A MySQL oldalán jelenleg a What's New szekcióban nem kommentálják az esetet.

A hír fényében érdemes újra elolvasni a Slashdot eszmefuttatását is.

A SUN hivatalos bejelentése

 

Amióta elöször KEdittel dolgoztam (békebeli Clipperes idők), azóta rajongok a blokk-kijelölésért. 

Az Eclipse-ben erre eddig nem volt lehetőség, de most az Eclipse 3.5 M5 verziójától bárki élhet vele. Használd a fenti nyomógombot, vagy állítsd át a kijelölés módját Alt-Shifht-A -val.

Milyen kár, hogy mi még a 3.3-as Eclipse-et használjuk, és éppen csak most állunk át a 3.4-esre. 

via Eclipse Tip

Security Framework-ünkhöz felmerült az igény, hogy a felhasználó csak azokat a perspektívákat lássa, amikre joga is van. Eddig ugyanis csak View szinten tudtuk lehetővé tenni a megjelenítés megakadályozását a createPartControl kézben tartásával.

A meglévő Open Perspective menüt átírni annyira macerás, hogy szinte lehetetlen, cserébe viszont könnyen írhatunk saját perspektíva kezelő menüt.

A feladat megoldását két új osztály biztosítja, a PerspectiveSwitcherToolbar és a PerspectiveSwitcherMenu.

A két osztályt kétféleképpen integrálhatjuk a programunkba. Amennyiben a menüket és a CoolBart saját magunk programozzuk, akkor az ApplicationActionBarAdvisor-t kell kezelésbe vennünk, és az alábbi kódrészletet a megfelelő metódusokba el kell helyeznünk:

protected void fillMenuBar(IMenuManager menuBar) {
...
MenuManager perspectivesMenuMgr = new MenuManager("Perspectives", "Perspectives");
PerspectiveSwitcherMenu perspectiveSwitcherMenu = new PerspectiveSwitcherMenu();
//register(perspectiveSwitcherMenu);
perspectivesMenuMgr.add(perspectiveSwitcherMenu);
menuBar.add(perspectivesMenuMgr);
...
}


protected void fillCoolBar(ICoolBarManager coolBar) {
...
ToolBarManager tbm = new ToolBarManager();
tbm.add(new PerspectiveSwitcherToolbar());
coolBar.add(tbm);
...
}

 

A másik lehetőség,  hogy a menüt és a toolbart a plugin.xml-en keresztül állítjuk be.

(Videó megtekintése teljes méretben: Screencast Eclipse plugin.xml állítás)

 

Ha mindezt megtettük, akkor a plugin.xml forrása a következőképpen fog kinézni:

   <extension
point="org.eclipse.ui.menus">
<menuContribution
locationURI="menu:org.eclipse.ui.main.menu">
<menu
id="menu.perspectivesDynamic"
label="Perspectives (dyn)">
<dynamic
class="hu.xsolutions.example.perspectivemenu.PerspectiveSwitcherMenu"
id="perspectiveSwitcherMenu">
</dynamic>
<separator
name="perspectives.separator1"
visible="true">
</separator>
<command
commandId="org.eclipse.ui.window.newWindow"
style="push">
</command>
</menu>
</menuContribution>
<menuContribution
locationURI="toolbar:org.eclipse.ui.main.toolbar">
<toolbar
id="toolbar.perspectivesDynamic">
<dynamic class="hu.xsolutions.example.perspectivemenu.PerspectiveSwitcherToolbar"
id="perspectiveSwitcherToolbar">
</dynamic>
</toolbar>
</menuContribution>
</extension>
 

A plugin.xml-t direktbe inkább ne editálgassuk, mert nem szereti. Inkább végezzük el fentebb a GUI-n keresztül a megfelelő beállításokat. 

Ne felejtsük el mindkét esetben az ApplicationWorkbenchWindowAdvisor-ban elvégezni az alábbi beállításokat:

public void preWindowOpen() {
...
configurer.setShowPerspectiveBar(false);
configurer.setShowCoolBar(true);
... }

Forrás 

A kód Java 1.4 kompatibilis.

A teljes kódot itt letöltheted: hu.xsolutions.examples.perspectiveMenu.zip

A programozók életük egyharmadát egy székben töltik, de a legtöbben nem csak munkaidő előtt ülnek a gép előtt, hanem otthon is. Nem mindegy hát, hogy ezt az időt milyne körülmények között töltjük.

Ahogy fontos a jó számítógép, úgy fontos az is, hogy kényelmes, ergonómikus szék támassza hátunkat, hacsak nem akarunk 5-10 év után hátfájdalmakra panaszkodni. A Coding Horror összegyűjtött néhány megfelelő széket. 

Szorgos programozók összegyűjtötték 366 programozási és 58 emberi nyelven azt, hogy miképp mondjuk "Hello World".

// Hello World in Java

class HelloWorld {

    static public void main( String args[] ) {

        System.out.println( "Hello World!" );

    }

}

Forrás: The Hello World Collection

Okosabb vagy, mint egy csimpanz? Jo kis jatekot talaltam, pihentetoul ajanlom mindenkinek:

http://games.lumosity.com/chimp.html

Elolvasom »

Minden kedves latogatomnak kellemes karacsonyi unnepeket kivanok!

Mr.A hivatalos kozlemenye: 

Uj szerverre koltoznek a blogok, ezert lehet, hogy 16-48 oran keresztul kisebb-nagyobb fennakadasokkal szembesulhet a kedves latogato.