Tag: eclipse

vilket_är_lättast_AttLäsaTyckerDu

Jag har skaffat mig en åsikt: det_är_lättare_att_läsa_vanlig_text_så_här, änAttLäsaDetNärDetStårSammanSkrivetUtanNågonWhiteSpace. De flesta känner till att vi mnäskionr kan lsäa ord unta srröte poerblm bara start- och slutbokstaven står på rätt plats. FrsöökGröaSmmaaSakMedDtetaTxbtelcok. Så, jag har skaffat mig åsikten att underscore är en bra idé att använda i t ex namn på test(metoder). I JavaScript brukar de flesta testramverk erbjuda följande mönster:

TestCase("Nu testar vi logiken i UserManager", {
    "lägga till en användare": function() {
        var before = this.userManger.getUserCount();
        this.userManager.addUser("Fredrik", "Wendt");
        var after = this.userManger.getUserCount();
        assertThat(after, equals(before + 1));
    }
});

Det är då ganska lätt att se vad som gått fel när en rapport säger:

In Suite "Nu testar vi logiken i UserManager", the test "lägga till en användare" failed.

I Java kan vi inte använda blanktecken som del av identifierare. I Java 7 kan man iaf använda 1_000_000 för att skriva ut en miljon, yay! Men det löser inte problemet med att få läsbara namn på test(metoderna). Understreck till räddning!

Ett problem som följer med understreck är att Eclipse rätt ur lådan inte stödjer att hoppa inom identifierare som innehåller just understreck: ctrl+höger hoppar alltså till slutet av hela identifieraren. Med AnyEditTools (finns på Eclipse Marketplace) blir detta problem ett minne blott, och man får också hjälp att konvertera mellan Camel Case och Underscores. Perfekt julklapp! :)

Eclipse Patch/Compare Settings

Av oklar anledning skeppas Eclipse med standardinställningar enligt nedan. Jag har ännu inte sett någon aktivt använda Structure Compare-ytan i toppen när man diffar/jämför två versioner av en fil. De tre röda ringarna byter jag i mina workspaces.

Eclipse, The Compare/Patch Preferences

Eclipse, The Compare/Patch Preferences

PyDev: Pythonutvecklingsmiljö

PythonPyDev är baserad på Eclipse, funkar väldigt bra för det jag gör, vilket i princip är att försöka jobba på samma sätt med Python-kod som med Java (TDD-ish = få ut kod i jämnt flöde och refactor för att få det fint).

Vid dagens diskussioner kring tools och miljöer på GothPyCon ][ så gjorde jag följande anteckningar (“konferensen” hölls på engelska) över features jag förväntar mig i en IDE:

  • graphical, remote debugging
  • virtual environments
  • syntax highlighting
  • unit test integration with coverage
  • auto completion
  • indentation
  • inline documentation
  • refactoring
  • easy navigation

Allt detta – förutom debugging – demonstreras i en fem-minuters demo på PyDevs hemsida, ihop med de tangentbindningar som är “speciella” för PyDev:

Shift+Alt+n
Shift+Enter
Ctrl+2, r
Shift+Alt+a
Ctrl+F9
F12
Ctrl+F11
Ctrl+Alt+l
Shift+Ctrl+Alt+m
Ctrl+Alt+↓↑
Alt+↓↑
alt+→

JsTestDriver

Most of my code writing time last week writing was spent in JavaScript land (or ECMAScript, wonder it the most commonly used name will ever change). I was to write a small templating package and had to write some new stuff and set out to use JsTestDriver and after a few minutes I was up and running in Eclipse.

The idea is OK I guess – run tests and production code in the same environment it will run in when deployed. There are a couple of cons to JsTestDriver (used through Eclipse) though:

  1. if you’re configuration file doesn’t include the test file you’re trying to execute, there’s no clue to what you’ve done wrong – the panel in Eclipse will just show the green bar and 0/0 tests run.
  2. if you have syntax (or construct like) errors in your unit under test, you’ll get the same behavior as above
  3. sometimes you’re served a cached version of (some of) the JS source files – hence there’s a button to “refresh browsers” and it’s sad that it has to be there and that you actually have to use it
  4. sometimes the engine gets into some strange state where it dryRuns the tests instead of actually executing them

Apart from that, its behavior is quite predictable. Minor issues:

  1. running a test complete locks Eclipse’s UI thread
  2. a Rerun quick command option would be great (Ctrl+3)

JsHamcrest

Another minor issue is that the “index” of JsHamcrest matchers is really hard to get an overview of. Whenever I wanted to use a certain type of matcher, it was really hard to quickly tell from the documentation if it was there or not. Go see for yourself and look for a matcher that mathes any object for instance.

JsHamcrest.Integration.JsTestDriver();
# get a list of matchers:
curl "http://jshamcrest.destaquenet.com/modules/matchers.html" | grep "dt id" |cut -d '"' -f 2 |cut -d '.' -f 3

JsMockito

JsMockito works really nice. The only thing that could’ve been better is the integration with JsTestDriver: when a verify step fails, you’ll get a good error message but you don’t get the typical feedback as from which line the verify/assert that failed was on. Not a big deal since you see which test that failed.

JsMockito.Integration.JsTestDriver();

apache, svn, mysql för prov

Idag skriver ett par elever omprov i kursen Avancerade Webbteknologier 1 i Agile Web Developer-programmet på kyh.se (yrkeshögskola). Deras prov består av två delar: en pappersdel och en “praktisk” del.

Den praktiska delen presenterar ett antal handritade skisser över en webbplats. I det första provet skulle de göra en enkel version av twitter. I detta prov ett enkelt forum. All hjälpmedel är tillåtna och poängen är att det skall vara likt en riktig arbetssituation. Studenten kan då visa vad han eller hon faktiskt kan åstadkomma på en viss tid, visa upp på kod han/hon väljer att checka in och visa prov på färdighet. Pappersdelen visar mest på nivå av kunskap – inte den hantverksmässiga färdighet man som utvecklare faktiskt bygger upp.

Hur funkar det då?

Förra gången uppstod konstiga fel för en del av de som satt på Windows och körde Eclipse med Subclipse. Problemet visade sig vara att de som inte köra “pure Java”-versionen, aka SVNKit, utan istället köra native-bryggan inte alls kunde interagera med svn-repot. Detta hade tidigare inte varit något problem under kursen, men då var alla läsoperationer tillåtna för hela världen (anonymous access) och endast skrivning krävde inloggningsuppgifter.

“Svn-repot” är egentligen flera repon – ett repo per student. De är skyddade så att bara ett konto kan komma åt just det repot, både vad gäller läs och skriv (och alla andra operationer). Repot accessas via HTTP och Apache via mod_authz_svn / mod_dav_svn (man får akta sig så att dav_svn.conf som medföljer vid installation inte används med default-inställningar).

Så, jag satte ihop ett par skript (bash och python) som

  • skapar svn-repo med branches, tags och trunk-kataloger (om det inte redan fanns),
  • skapar htpasswd-fil,
  • skapar apache-config-fil, samt
  • skapar MySQL-databas (en per person) och populerar med lite grunddata.

Konfiguration av Apache

Hela webbplatsen kör på en egen virtual host och konfigurationen för detta ligger i en enda fil. För varje student genereras följande:

<Location /live/carw949>
 AuthType Basic
 AuthName "Live - carw949"
 AuthUserFile /srv/prov/live/carw949.htpasswd
 Require valid-user
 Order allow,deny
 Allow from all
</Location>
<Location /svn/carw949>
 DAV svn
 SVNPath /srv/prov/svn/carw949
 AuthType Basic
 AuthName "AD10Gbg carw949"
 AuthUserFile /srv/prov/live/carw949.htpasswd
 Require valid-user
</Location>

Utöver det kör jag också ett cronjobb som checkar ut deras kod var tredje minut och lägger upp “live”. (Även denna “live”-katalog är skyddad och access ges bara till ett enda konto.)

Konfiguration av Subclipse och Eclipse

Idag fungerar det fint utan problem  för alla. Det gäller dock att man i Eclipse (med Subclipse-plugin) väljer att använda SVNKit istället för JavaHL (JNA). Installeras enklast via Help » Install New Software och med arkivet som finns på http://subclipse.tigris.org/update_1.6.x. För att kontrollera vilket SVN-lib (eller backend) som används så är vägen denna:

Window » Preferences
Team » Svn
Svn Interface » Client: SVNKit (Pure Java)

Alla skript ligger under http://wendt.se/software/education/kyh.se/awt1/ och do-it-all.sh gör “allt”. Filen elever.txt innehöll alla elever och var på det format som jag fick rått från SCAS (administrativt system).

Eclipse och TDD

Eclipse är ganska svagt utrustat från start för att köra TDD effektivt. Det verkar inte komma ifrån att code completion måste utföras med CTRL+mellanslag – här kommer IntelliJ för alltid lysa med sin vackerhet (där mellanslag eller tab är “markören” som kollar om den skall auto-complete:a).

Favorites

Följande klasser är bra att peta in i varje workspace Window » Preferences » Java » Editor » Content Assistant » Favorites:

  • org.junit.Assert.*
  • org.mockito.BDDMockito.*
  • org.mockito.Matchers.*
  • org.mockito.Mockito.*
  • org.mockito.MockitoAnnotations.*

Templates

Börja med att ta bort  alla SWT, ta bort test för JUnit 3.

WORK IN PROGRESS!

before

${staticImport:importStatic('org.mockito.MockitoAnnotations.initMocks')}
@${beforeAnnotation:newType(org.junit.Before)}
public void ${setup}() throws Exception {
  initMocks(this);
  testee = new ${cursor};
}

mock

@Mock private ${type} ${mock};

bdd – BDD Test

@Test public void statement() throws Exception {
    given(${mock}.${method}).willReturn(${value});
 
    // WHEN ${when}
    ${testee}.${act};
 
    // THEN ${then}
    verify(${mock}).${method}(${arguments});
}

tdd – TDD test

@Test public void statement() throws Exception {
    // Arrange
    // Act
    // Assert
}

JDojo – TDD i fem steg

Genom mitt jobb har jag haft det stora nöjet att få hålla ett antal kodningstillfällen som “lanserats” under namnet JDojo@Gbg. Det var tack vare Emily Bache som detta kom till stånd och när hon nu seglade vidare mot Ruby-landet så har jag tagit över vid rodret och det hela har, mer eller mindre, näst intill formaliserats i en serie beprövade övningar i olika ämnen (kurspaket om 10 timmar skulle säkert någon vilja kalla det).

Det som började med en ambition om att sprida TDD och andra goda principer för “hantverksyrket” programmering snappades ganska snabbt upp på olika arbetsplatser och till dags dato har snart fem olika grupper/JDojos genomförts (med fler i uppstartningsfasen) och detta är en liten sammanfattning (reflektion/retrospektiv) av hur det sett ut hittills.

Ämnen som avhandlats

Utan omsvep så har vi under dessa JDojos avhandlat följande ämnen, med – för alla deltagare – mycket givande diskussioner.

Testdriven utveckling

Ett ämne som försvaras ganska brett (värdet av en bra testsvit) men “lärs ut” ganska smalt. Under SDC2010 i en fishbowl-debatt på temat “Should every proffessional developer practice TDD” var de flesta överens om “nja, det viktiga är en bra testsvit, men hur man kommer fram till den är inte givet” medan Michael Feathers mer var av åsikten “outside of Sweden, this is more or less concidered the solution”.

The Solution, med “test first”, red-green-refactor, etc lärs ut eller gås igenom i denna första övning.

Clean Code

Efter en introduktion till TDD och själva processen tar vi upp saker som “test backlog” och fokuserar ännu mer på refactor-steget och diskuterar (och deltagarna på något sätt enas om) definitionen av Clean Code. Ett antal best practices tas fram och även om det låter som ett tunt ämne så är diskussionerna här alltid rika, nyanserade och har beskrivits som “mycket värdefulla”.

Objektorienterad utveckling och TDD

Nästa steg i utforskandet av TDD har varit att titta på vad som händer när man tar steget från “enklare” imperativ/funktionell programmering och in i det objektorienterade landskapet. Med rätt uppgift och lagom dos moderering tyder ett mönster fram som i princip går ut på mycket fokusskifte mellan klasser. Ganska snart i retrospektiven brukar ett samtal kring kring inside-out, bottom-up och top-down dyka upp.

Mockist vs Stubborn Approach

Efter att ha känt på det dyra med att skifta fokus fram och tillbaka med TDD och OO bjuder nästa övningstillfälle på möjligheten att med hjälp av mockning (Mockito) bibehålla fokus på “en klass i taget” och i större utsträckning kunna fokusera på interaktionen, gränssnitt och enskilda klassers roller. Syftet med mockning, och när det är lämpligt att mocka, blir tydligt i jämförelse med föregående övning.

Behaviour Driven Development

Den femte övningen har antingen fokuserats mot BDD om det funnits intresse för detta. Fokus har legat på formen av GIVEN, WHEN, THEN och det somliga kallar ryska dockor och andra utifrån-in eller outside-in.

Legacy Code / befintlig kod

Ett annat efterfrågat ämne är hur man inför TDD-tänk kring kod som inte redan täcks av test, eller kanske inte är testbar (eller iaf svårtestad). Michael Feathers bok “Working Effectively with Legacy Code” demonstrerar detta på ett utomordentligt bra sätt och i denna övning har vi tagit kundens befintliga kodbas (om möjligt/lämpligt) och bearbetat den för att uppnå olika mål.

Mer (än) rubriker

Givetvis avhandlas många olika aspekter av systemutveckling parallellt, t ex Characteristics of a Good Test, Enough Tests? 3A vs BDD? Baby Steps, TDD vs Traditional Testing, …

Workshop i Eclipse som mjukstart

Vid ett par tillfällen har vi inlett med en workshop om effektiv utveckling i Eclipse. Detta har gett utvecklarna en möjlighet att känna på Dojo-ledaren, och omvänt en möjlighet att anpassa materialet efter gruppens förkunskaper och önskemål.

Formen för övningstillfällena

Vi har i huvudsak använt Eclipse, JUnit, Mockito och FitNesse. De 120 minutrarna används effektivt med en introduktion av dagens övning och ibland av det ämne man skall behandla – värdet av självinsikt får vägas in här och anpassas efter gruppen. Ca 90 minuter används till utförandet av övningen och avslutas med en en lagom kort retrospektiv där övning, erfarenheter och reflektioner tas upp och blandas friskt.

Vad är en Coding Dojo?

Dojo är namnet på lokalen där bl a olika kampsporter utövas, t ex Karate. 2005 lanserades termen “Coding Dojo” (eller Coders’ Dojo) där principen är att man upprepat utför vissa övningar, så att man genom repetition övar upp olika färdigheter/kunskaper så att när man behöver dem i “skarpt läge” kan man med lätthet kan agera på ett korrekt och säkert sätt.

Ingen föresläsningsserie – aktivt deltagande ger verkliga erfarenheter

Den Java-Dojo som Iptor nu bedrivit har visserligen fått en uppsättning övningar som vi fått efterfrågan på, och därför kunnat upprepa med mycket liknande resultat. Det är dock inget föreläsningspaket som deltagarna kan sova sig igenom – tvärtom skall varje individ sitta i “the hot spot” och parpogrammera. Praktisk erfarenhet och kunskap är mål utöver teoretisk kännedom och bekantskap.

Material

Skall försöka peta ut allt material här. Ikväller blir än så länge bara följande:
JDojo1: TDD och
Kata String Calculator

Eclipse workshop-anteckningar

Hade en liten workshop om Eclipse och detta var anteckningarna jag utgick från (och 2010-04-13 höll jag en till, och uppdaterade sedan listan).

Eclipse GUI

* Workbench, Workspace, Sets, Project, Project linking/dependencies
* Package explorer – flat vs hierarchic layout
* View – SA+Q, Window > Show View, Detached view
* Perspective: C+F8, Window > Customize Perspective
* Flera fönster / workspaces

Project

* .classpath, .project
* Attach javadoc
* Attach source
* maven eclipse:eclipse -DdownloadSources=true -DdownloadJavadoc=true

Editor

* F3 F2 (source, javadoc)
* F12
* C+M
* Link with editor
* Templates – sysout > System.out.println()
* show line numbers, show print margin vs C+L
* CS+O C+mellanslag SA+D SA+X CS+F
* New Editor [editor1|edtior2]
* SA+R
* CS+G – FilterBidResult.MATCH
* C+E, C+F6 CS+F6
* bind:a om tangenter till Ctrl+Tab – Window > Prefs > General > Keys
* Alt-<, Alt->
* Alt-v, Alt-^
* CS+T ype
* CS+R esource
* Mark occurance / highlight SA+O – visas i listen till höger om rullningslist
* Team compare, local history

Ctrl+1

* Visa: ta bort TripAction convertToProperFormat
return null;
return result; C+1
* Visa:
obj.method(); C+1
x = obj.method(); C+1
String x = obj.method(); C+1

Debug

* Breakpoints med krav
* CS+B
* F5 step into, F6 step over, F7 step out, F8 run
* C+3 Rerun
* Break på Exception, t ex AssertionError, NullPointerException

Remote Debugging

* -Xdebug –Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=1234
* t ex
** websphere

http://pa-blogger.blogspot.com/2008/08/debugging-websphere-with-eclipse.html

** JBoss
** externa applikationer? mvn jetty:run

CVS

* Team compare (se allt som hänt mellan olika datum)
* Flytta root/server

History

* local vs remote
* eclipse -clean

XML Schema

* XML Catalog – installera schema för att få content assist
* Generate XML file – få exempelfil utifrån schema
* Namespaces?

Views

* Problems

** Quick fix

* Tasks

** FIXME, TODO

* Search

** next match/annotation (C+, C+.)
** history

* Servers

** Configuration

* Console

** follow output

Lite andra saker

* Aptana – för JavaScript-redigering (egentligen dynamiska språk)
* MyEclipse – plugins för koppling till BugZilla/JIRA