1. all your base are belong to us

    The spreadsheet has been the tool of choice for my wife’s small business; pretty much wysiwyg with no real hidden data models or business processes or odd UIs. Just type in the data.

    ahh but the problems with these spreadsheets- multiple machines, not backed up, office vs. openoffice… had them all.

    well, since her business already uses some Google services (gmail, calendar), why not Google Docs & Spreadsheets? Yes this solves issues with backups and multiple copies. What about availability? For her, being online is not a problem (and the Google servers have better uptime then her laptop). As for functionality, the simple equations in her worksheets work as expected.
    But this is all pretty boring for me, until you add in the nice set of APIs available to Google Apps (Google Spreadsheets, Calendar, Gmail, etc.). Now look what your code can do with all that manual entering of information:

    Read entries from a spreadsheet as Atom/RSS feeds for product catalog and pricing info. Sure this is easily Spring configured or in a database, but my wife updates this: putty/linux/SQL or typing in a spreadsheet?

    Placing order information into ”template” worksheets for generating packing lists, invoices, late payment reminders.

    Creating calendar events for invoicing, payment and other CRM issues

    Querying on these events to trigger other business (PDF generation and email is easy manually with Docs & Spreadsheets, not sure if API for this is available).

    Most of these APIs utilize the REST influenced GData API to GET / POST / PUT / DELETE information either publicly or securely via the Google Account Authentication.

    There are client libs for java/net/php etc and even JSON for you script kiddies. So try some programmatic access to your blogger data, local maps or youTube videos… but remember, its free and probably beta !

  2. The most complete list of -XX options for Java 6 JVM

    Om du trodde att du hade koll på alla -XX options till Java SE 6 så är det nog bäst att kika på Eugene Kuleshov’s ”The most complete list of -XX options for Java 6 JVM”.

  3. Expo-C, dag 2

    Idag var jag och en kollega på Expo-C i Göteborg. Det var en dag som mixade intressanta diskussioner och insikter. Dagens talare var av blandad härkomst och ålder vilket belyser två saker

    • Det tar tid att bemästra utveckling
    • Tid != ålder, det handlar om att andas utveckling, koda mycket och att vara nyfiken på vad man gör!

    Jag gillade Jim Coplien’s review över historien kring Agile och Rickard Öbergs (blog) beskrivning på vad en Aspekt var för honom och vilka fördelar han såg med det (framförallt väldigt god återanvändbarhet). Rickards (och kollegors???) tankesätt har gjort att de kunnat nå mål med avseende på produktivitet som normalt sett skulle anses omöjliga.

    En annan källa till inspiration är Dan North och hans sätt att bedriva design genom fokus på beteende (BDD, jBehave) och hur man ökar förståelsen för TDD genom att fokusera på detta beteende.

    Jimmy Nilsson (blog) talade om nöden att söka lösningar och metoder utanför sin bekväma, upplysta bakgata och Ralph Johnson beörde utveckling av idag och hur det till stor del handlar om att underhålla befintlig kod. Ralph talade även om refactoring ur ett historiskt perspektiv.
    En intressant reflektion kopplad till BDD som jag just fick upp…mitt beteende i livet driver till stor del min egen utveckling. Dan North kanske inte var först när allt kommer omkring?!?!   ;-)

  4. Koda snabbt som F*N! (The IntelliJ way…)

    I min presentation för JavaOne beskriver jag hur du kan skriva ett 3D spel på mindre än 50 minuter. Detta har gjort att vissa höjt lite på ögonbrynen och ställt sig tveksama till att det faktiskt går att skriva det så snabbt. Spelet som jag presenterar består av ungefär 1400 rader kod, varav ungefär 500 är automatgenererade getter/setters och dylikt. I princip så har jag alltså manuellt skrivit ungefär 900 rader Java-kod på mindre än 50 minuter. Det betyder 22,5 rader per minut. Jag räknar med i genomsnitt ungefär 40 tecken per rad, vilket då resulterar i att jag måste slå 720 slag på tangentbordet varje minut i 50 minuter för att hinna med alltihop. Jag läste på Wikipedia att den genomsnittlige datoranvändaren skriver mellan 50 och 70 ord per minut, där varje ord är i genomsnitt 5 tecken lång, d.v.s. 350 tecken per minut som mest (världsrekordet ligger på 150 ord-per-minut under 50 minuter, innehas av en Barbara Blackburn). Det är alltså en bra bit från de 720 tecken/minut som jag behöver uppnå. Så hur kan jag hävda att det är möjligt?

    Beroende på hur man ser på det så fuskar jag. Jag använder själv IntelliJ IDEA (6.0 för närvarande) för all Java-kodning. Överlägset stöd för code-completion, refactoring, templates och annat trevlig godis för utvecklare. Ta följande exempel; jag ska skapa lägga till en ActionListener på en knapp. Jag har skrivit följande kod och markören står på *.

    JButton button = new JButton(”Kör”);
    button.addActionListener(
    *);

    Sen långt tillbaka har vi haft grundläggande code-completion där jag skriver variabelns namn, punkt, och sen trycker Ctrl-Space (eller dylikt) och får upp en lista på alla metoder som kan köras på det objektet. IntelliJ tar det hela ett steg längre, nu skriver jag bara följande (i fetstil) och trycker på Ctrl-Shift-Space:

    JButton button = new JButton(”Kör”);
    button.addActionListener(
    new );

    Resultatet nu är att IntelliJ fattar att det är en ActionListener som ska in där. Den presenterar en lista med alla klasser och interface som skulle passa där (alla klasser som implementerar ActionListener och som ligger i projektets classpath). Nu vill jag inte använda en färdig ActionListener, utan skapa ett anonymt inre objekt. Väljer jag då ActionListener av de alternativ som finns i listan så fixar IntelliJ all boiler-plate kod åt mig automatiskt, resultatet blir alltså, utan att jag behöver skriva ett tecken mer, att jag får följande helt automatiskt (markören hamnar på *):

    JButton button = new JButton(”Kör”);
    button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
    *
    }
    });

    Detta funkar för alla typer av anonyma inre klasser och även för sånt du skriver själv. Väldigt smidigt alltså. Denna intelligent code-completion fungerar på fler ställen. Definerar jag en variabel av typen Map så räcker det med att jag skriver variabelns namn, ett = tecken och new och IntelliJ ger mig en lista över alla klasser som implementerar Map. Väldigt trevligt.
    Detta är bara ett litet smakprov av vad IntelliJ erbjuder dig som kodare. Trivilia saker som ofta kräver mycket manuellt skrivande görs i ett nafs. Refactoring-stödet är smått magiskt och har under de 6-7 år som jag använt IntelliJ väldigt sällan fallerat. Nu vet jag att både Eclipse och NetBeans erbjuder smart code-completion och refactoring, men ingen av dem är ens i närheten av de finesser som IntelliJ har.

    Baksidan är att IntelliJ kostar pengar. $499 för att vara exakt. Väl investerade pengar enligt mig. För de som vill testa IntelliJ så kan du ladda hem en trial licens på 30 dagar. Du hittar allt på www.intellij.com.

  5. Javaforum fullbokat — igen!

    Javaforumet den 23:e Maj i Göteborg är nu fullbokat! Vi har valt att sätta en begränsning på 150 deltagare för att det inte skall bli för stort och stelt. Vad tycker du — skall vi öppna upp för fler eller räcker det?

  6. Fråga efter JavaObjekt

    Ibland, exempelvis när man har stora datamängder i objektträd, kan det vara bökigt att leta upp specifikt data utan att hamna i fula stora iterator-if-else konstruktioner. I dessa lägen kan ett objektfrågespråk vara lysande. I Apache Commons finns JXPath som är ett sådant frågespråk. Inte helt väldokumenterat, men Bart van Riel har skapat en bra tutorial jag kan rekommendera.

  7. Populära men anonyma bakgrundsbilder

    I morgonens Computer Sweden läste jag om en konstnärsstudent som letat upp motivet till Windows XP:s bakgrundsbild bliss

    bliss

    och tagit ett eget fotografi på motivet/kullen, typ 10 år efter att orginalfotot togs. Studenten verkade ha behövt stångas med Microsoft brevledes ett bra tag innan han kunde lokalisera kullen. En liknande men utförligare redogörelse om hur en journalist på Vanity Fair med stor möda letade upp motivet till XP:s andra bakgrundsbild autumn

    autumn

    och fann det i Ontario, Canada. Fascinerande detektivarbete.

  8. Ska du till JavaOne?

    Om så är fallet så kanske du skulle tycka det vore intressant att träffa fler likasinnade svenskar. Bert Rubaszkin på Sun här i Sverige har tagit det strålande initativet och dragit ihop en kvällsaktivitet för oss svenska JavaOne-besökare den 9:e maj i San Fransisco. Själv tycker jag det vore trevligt om man kunde träffas innan också, särskilt då jag åker själv. Jag kommer flyga från Arlanda klockan 09:45 lördagen den 5:e maj (via Chicago) och bo på Pickwick Hotell. Om det skulle vara någon som ska åka samma tid eller har lust att möta upp på JavaOne så kan ni ju skicka mig ett mail på erik.hellman(snabel-a)ibs.se.

    Tid och plats för min presentation har blivit spikad nu också. Klockan 18:35, torsdagen den 10:e maj, i Hall E – 135 så kommer jag köra min session ”Write a 3-D Game in the Java Programming Language in Less Than 50 Minutes” (TS-3073). Om du planerar att gå på den så är det bra ifall du anmäler dig i förväg då antalet platser i varje sal är begränsat.

  9. UTF-8?

    Efter att jag skrev mitt inlägg om encoding i XML så har jag fått frågan om vad som skiljer UTF-8 mot, t.ex., ISO-8859-1. Det kan alltså vara på sin plats att förklara vad UTF-8 egentligen är och vad som gör det så bra.

    De traditionella encoding standarderna, t.ex. ASCII eller ISO-8859-1, har alla en sak gemensamt. Varje tecken som den definerar tar lika mycket plats som alla andra, vanligtvis en byte (eller 8 bitar). UTF-8 har en variabel längd för varje tecken, som mest 4 bytes. I princip så gäller följande;

    - För de gamla hederliga 128 US-ASCII tecknen så behövs en byte. Första biten är 0.

    - För alla tecken inom latinska alfabetet (Latin character set), grekiska, cyrilliska, armeniska, hebreiska, syriska och thaanaska så behövs 2 bytes. Första byten har då de två första bitarna satta medan den följande har första biten satt.

    - Övriga tecken inom det s.k. ”Basic Multilingual Plane” (kort sagt samtliga tecken som används på jorden) använder tre bytes där första byten har sina tre första bitar satta och de övriga har första biten satt.

    - En fjärde byte kan behövas för väldigt speciella tecken. I dessa fall har första biten de fyra första bitarna satta medan de övriga har första biten satt.

    Ok, detta betyder alltså att så länge som du befinner dig inom standard US-ASCII (de första 128 tecknen) så brukar man inte märka någon skillnad mot andra encoding standarder. Det är troligtvis därför som så många har ignorerat hela problematiken med encoding. Problemet för oss i Sverige uppstår ju första när vi skriver å. ä eller ö. Eftersom dessa, när vi använder ISO-8859-1, ligger bortom de första 128 tecknen, så får vi alltså första biten satt och vår XML-parser blir smått förvirrad när den inte kan decoda tecknet som den skall.

    UTF-8 definerar alltså totalt 1048576 tecken, tillräckligt för alla tänkbara tecken vi använder idag. Det finns också två andra standarder, UTF-16 och UTF-32. Dessa tillåter båda fler tecken än UTF-8 medan de fortfarande tar 4 bytes som mest. Problemet är att de också tar mer plats generellt, eftersom man sällan använder tecken ovanför de första 128 . UTF-16 tar som minst 16 bitar och UTF-32 tar alltså 32 bitar. Alla dessa tre standarder, tillsammans med ett par andra, ingår i Unicode version 3.0. Förkortningen UTF står för Unicode Transformation Format och siffran efter anger hur många bitar varje ”code point” tar.

    UTF-8 är designat så att den ska passa bra i stream-orienterade miljöer (vilket i princip är allt där vi läser och skriver data idag). Det intressanta är att man faktiskt inte behöver läsa från början, det är fullt möjligt att hoppa in ”i mitten” och börja läsa där, utan att riskera att hamna ur sync. Detta beror ju på att alla bytes som börjar på 1 är en del av ett mutli-byte tecken medan de som börjar på 0 eller 11 är början på ett tecken.

    Standarden är relativt ung (1993) och började inte användas på allvar förrän XML dök upp. Java har hanterat UTF-8 ända sen första versionen. Dock har Java gjort två modifikationer på UTF-8 internt (kallas modified UTF-8). Den första skillnaden är att null-tecknet kodas med två bytes när man serialiserar ett objekt. Detta för att förhindra att om man läsa in ett serialiserat Java-objekt i, t.ex., C så tolkas en tom byte (8 tomma bitar alltså) som en avslutning på en sträng och skulle alltså ställa till problem. Den andra skillnaden beror på att ett tecken i Java alltid är 16 bitar (storleken på en char). Detta gör att tecken utanför ”Basic Multilingual Plane” (d.v.s., tecken som kräver 4 bytes i UTF-8) behöver två stycken Java tecken för att kodas. Dessa skillnader slipper dock vi utvecklare tänka på (såvida du inte hackar på kompilatorn eller leker med de interna delarna av String-klassen), så vi kan gott leva vidare och tänka ”vanlig” UTF-8 när vi kodar.

  10. TeXML

    Har någon sysslat med TeXML?

    TeX är ju ett layoutspråk för trycksaker. Mycket moget sådant. Verktyg för att generera Postscript och PDF från TeX är utmärkta, fria, och används inom den grafiska industrin.

    XSL-FO (formatting objects) är ungefär samma sak som TeX, fast i en XML-syntax. Att stila XML med hjälp av XSL-FO är ju egentligen att transformera sitt källdokument till ett XSL-FO-dokument.

    När man har sitt XSL-FO-dokument så måste man ha en renderare för att kunna betrakta, eller skriva ut, sitt dokument. Det finns renderare till bilder, och renderare till PDF. Problemet är att dessa renderare är mycket mindre mogna än motsvarande TeX- (och LaTeX-) renderare.

    TeXML påstår sig vara räddningen. Det är en XML syntax som efterliknar TeX-syntaxen. Vilket gör att det blir enklare att konvertera till TeX. Och till TeX är renderarna mycket mogna.

    Istället för att stila sina XML-dokument med XSL-FO, så föreslår folket bakom TeXML att man ska stila dem med TeXML. Det sägs att det är precis lika enkelt/svårt som XSL-FO.

    Nu undrar jag: är det någon som vet huruvida detta är sant eller ej? Någon som provat?

    http://getfo.org/texml/

  11. [REST 2] Kommunikationsmodellerna: REST och SOAP

    I förra inlägget sade jag att REST var ett designmönster där man använder HTTP som applikationsprotokoll, inte som i SOAP som försöker vara protokollagnostiskt och som betraktar HTTP som ett transportprotokoll, ett slags TCP som kan ta sig genom brandväggar.

    Nå, att REST använder HTTP som applikationsprotokoll betyder att applikationer skrivna efter REST-mönstret ärver egenskaperna från den kommunikationsmodell som HTTP bygger på.

    Detta är ju inget konstigt. SOAP ärver egenskaperna från sin kommunikationsmodell. SOAPs modell kan vi kalla för RPC-modellen som i sin tur är en distribuerad variant av den vanliga ”message passing object oriented”-modellen (Java, C++, m fl).

    Message-passing, det betyder att all interaktion med ett objekt går ut på att man skickar ett meddelande till det objektet (populärt kallat: ”anropa en metod på objektet”). Oavsett vad meddelandet ska göra (ta bort, lägga till, förändra, ingenting).

    I RPC-modellen finns det ett ”objekt” (eller egentligen ett interface) på en annan datamaskin. Metoderna i detta interface kan man anropa, nästan som vore de lokala anrop (i alla fall är det så det ska kännas). Det är RPC-modellens styrka: den imiterar lokala anrop så gott det går. Och så funkar ju EJB, så funkar CORBA, så funkar XML-RPC och så funkar SOAP:

    //ganska begripligt interface, enkelt att omvandla till
    //distribuerat objekt såsom SOAP, CORBA EJB m fl.
    
    public Customer findCustomer( String searchString);
    public void saveCustomer( Customer customer);
    public void removeCustomer( String customerId);
    public double getCurrencyMultiplier( String currencyIso);
    public String[] getCurrencies();
    

    REST å sin sida handlar om webben. Och webben är bland annat följande:

    • En gigantisk samling resurser, som oavsett vad de är för något, är åtkomliga via varsin URL. På lika villkor.
    • En plats där man enkelt kan be om en resurs, och den kommer till en i form av en radda oktetter (bytes). Oavsett om det är ett foto eller om det är en väderprognos eller om det är ett javaprogram. På lika sätt.
    • Även om webben är agnostisk i vad den skickar, så meddelar den prydligt vad oktettströmmen ska tolkas som: text/plain, image/png, application/x-java-jnlp-file, x-whatever/x-from-the-future.
    • Att be om en resurs kallas för GET. Det finns även PUT för att placera en resurs på en URL, och DELETE för att ta bort en resurs på en URL.
    • Det handlar om en tillståndslös kommunikation. I grund och botten struntar protokollet HTTP i om du bad om en viss resurs alldeles nyss, för HTTP är alla anrop lika. Tillståndet bestäms istället av vilken resurs klienten råkar titta på för tillfället.
    • Däremot innehåller protokollet sätt att be en användare identifiera och autentiera sig, vilket ju är det vanligaste skälet till att man alls vill ha sessioner. Men autentieringen och auktorisationen äger alltså rum en gång per anrop.

    Vad innebär denna skillnad? Jo…

    Webbmodellen stödjer tre specialmeddelanden: Hämta resurs, Spara resurs, Ta bort resurs. Verben GET, PUT och DELETE. Precis som ett filsystem, fast med globalt åtkomliga objekt.

    Kan du nu förklara för mig hur gränssnittet ovan (findCustomer() osv) skulle kunna se ut, om man istället tänkte i REST-banor?

    Helt riktigt. När man modellerar system, så inser man att dessa tre verb är tillämpliga på i stort sett alla objekt. PUT är en införande, eller en förändrande, händelse, DELETE är en borttagande händelse. GET är ju helt enkelt att betrakta ett objekt, en betraktande händelse, en händelse som inte ska påverka objektet självt.

    Vi ser att alla metoderna i vårt interface ovan är av dessa tre slag. Fast för olika resurser:

    GET /customers?name~Ola*
    
    GET /currencies
    
    GET /currencies/USD
    
    PUT /customers/Ola
    
    DELETE /customers/Ola
    

    Nästa gång ska vi titta mer på varför och hur.

  12. Allt du behöver veta som programmerare lärde du dig redan på dagis.

    Enligt The Codist är reglerna på dagis applicerbara på hur man ska tänka och arbeta som programmerare. Läs mer på The Codist

  13. En enkel lösning för att läsa in 3D Modeller i Java

    Som jag tidigare har skrivit så ska jag åka till JavaOne nu i maj och hålla en presentation med titeln ”How to write a 3D computer game using Java in less than 50 minutes.”. Detta låter kanske som ett ganska djärvt påstående, så jag tänkte berätta lite om en av de större utmaningarna som jag haft med att ta fram denna presentation.

    Som ni säkert vet så brukar man skapa de 3D modeller som används i spel med hjälp av ett 3D-modelleringsprogram, t.ex. 3DStudio MAX eller Lightwave. Den fil (eller filer) som dessa skapar kan liknas vid ett serialiserat 3D-objekt. För den som vill ladda en 3D-modell så behöver man alltså lista ut strukturen på formatet (eller hitta specifikationen) och sen skriva en parser som läser igenom filen och skapar objektrepresentationen av det hela. Låter ganska enkelt, eller hur?

    Faktum är att det är väldigt enkelt att skriva en parser som laddar en fil från en 3D-modellerare. I mitt fall handlar det om COLLADA-formatet som jag exporterat från 3D modelleraren Blender. COLLADA är ett öppet XML-baserat format som använda för att beskriva en 3D scen (Läs mer om COLLADA på http://www.khronos.org/collada/). Bland annat så har Sony valt att använda COLLADA som det standard-format som 3D modeller ska ha i PlayStation 3. Genom att använda det XML schema som finns för COLLADA så kan jag enkelt generera klasser (Java Beans) för varje element som min 3D-modell består av. Genereringen gör jag med hjälp av ett API som heter XMLBeans. Man tar kort och gott ett XML Schema, kör XMLBeans schema-compiler och vips så har du en jar-fil komplett med kompilerade klasser för alla element som finns beskrivet i ditt schema. Därefter är det en bara att läsa in din XML-fil på följande vis:

    COLLADADocument parsedDocument = COLLADADocument.Factory.parse(new File(fileName));

    COLLADADocument är en genererad klass som representerar en COLLADA-fil. Från det objektet kan jag sen stega mig ner till alla element som min 3D-modell innehåller och enkelt läsa upp datan så som jag vill använda den i min applikation. På detta vis får jag snabbt och enkelt en parser för att ladda mina modeller. Det enda du behöver känna till är strukturen på formatet, något som är ganska enkelt att lära sig då COLLADA är ett öppet format och det finns rätt mycket dokumentation för den som vill fördjupa sig.

    Det man upptäcker rätt snabbt då man börjar med 3D programmering är att inläsning av 3D-modeller är något som ställer till rätt mycket. Det finns en hel del s.k. loaders tillgängliga, men alla dessa är helt beroende av det 3D API (t.ex. Java 3D eller Xith 3D) som de skrevs för. Du kan alltså inte använda dessa loaders utan att samtidigt behöva binda upp dig till ett stort och ofta komplext ramverk. Men ovan beskrivna metod så kommer du förbi det problemet. Allt du behöver göra är att ta din 3D-modell, läsa in den i Blender (eller vilket program du nu väljer använda) och exportera den till ett XML-baserat format (Det finns två stycken öppna standarder baserade på XML, COLLADA och X3D).

    Eftersom klasserna som skapas med XMLBeans följer JavaBeans-standarden så finns det väldigt intressanta saker man kan göra här. Spring Framework för spelprogrammering någon?

    XMLBeans har även många andra användabara områden, så jag rekommenderar er att ta en titt på det om ni ska jobba mycket med olika XML-dokument i Java.

  14. Dokumentation någon?

    Träffsäker strip om ett projekts olika ”faser”: http://www.noise.se/project.jpg