Da har vi feiret nyttår, og på denne tiden tenker jeg alltid mye på hvordan det nye året vil bli og hva jeg ønsker å gjøre anderledes. Jeg er vel ikke alene om det. Her skal jeg forsøke å samle tankene, og skrive ned noen forsetter – forhåpentligvis i form av konkrete mål. Ting som over tid skal gjøre meg til en bedre, sterkere og raskere utvikler. Fellesnevneren for mye av det er fokus.

Mindre random, planløs surfing

Alt for ofte flipper jeg opp laptopen uten å vite hva jeg skal. Jeg surfer på måfå, er innom diverse forum, sjekker infoq og andre relevante aggregator-sites, facebook, twitter, og mail – uten egentlig å oppnå så veldig mye. Dette er sløs med tid! Hvis jeg er opplagt bør jeg i stedet programmere, eller lese noe jeg allerede har planlagt å lese. Er jeg på jobb bør jeg jobbe. Er jeg ikke opplagt bør jeg ikke åpne laptopen i det hele tatt.

Jeg skal ikke slutte helt med sosiale medier eller å hjelpe folk på forumene, men jeg bør begrense det kraftig – det har tatt litt overhånd.

For å få til dette bør jeg nok lage meg en plan for hvor ofte og når jeg faktisk får lov til å sjekke disse tingene. Jeg har ikke kommer opp med noe konkret her enda, men det skal jeg!

Høyere fokus på jobb

Jeg lar meg lett distrahere. Oppdager jeg noe nytt og spennende, eller får en tanke om noe som hadde vært greit å teste ut, så er det ofte vanskelig å konsentere seg om det jeg burde gjøre. Møter og email-kommunikasjon er også forstyrrende, og totalt sett gjør dette at jeg i perioder ikke er særlig produktiv.

Jeg må lære meg å administrere min egen tid og mitt fokus bedre. Pomodoro var en teknikk som hjalp noe. Men jeg trenger mer. Jeg ser for meg at jeg må strukturere arbeidsdagen – sette av tidsbokser for epost, forberedelse til møter, oppfølging av teamet og lignende. Jeg må passe på at jeg ikke må context-switche for ofte, for det er krevende for dem som driver med programmering.

Lese

Jeg har alltid vært flink til å lese, men i høst har jeg lest for lite – og som jeg sa i denne blogposten skyldes det blant annet at jeg har sluttet å reise kollektivt. Planen nå er derfor å sette av én time hver kveld til lesing. Det gjør ikke noe om jeg ikke får lest hver eneste dag, men regelen skal være at jeg leser om det ikke er noe annet jeg skal gjøre.

Fysisk trening

Vi har et fantastisk treningstilbud på jobben som jeg ikke har vært flink nok til å benytte meg av. Trening er noe jeg gjør i perioder – ofte holder jeg på i tre, fire måneder, for så å “glemme det” i en minst like lange periode. God fysisk form er viktig for å kunne holde på konsentrasjonen og for å få utslipp for stress. Dette må jeg bli bedre på.

Mestre tastataturet

Jeg har en gjennomført (eller fastgrodd) tastaturteknikk som fungerer greit nok. Jeg skriver nå opp mot 46 WPM når jeg fokuserer maksimalt (målt på typingtest.com). Men jeg skriver med få fingre, og ser mye på tastaturet.

Skrivehastighet og teknikk er viktig for å komme i god flow. Jeg ønsker derfor å lære meg og øve inn touch. Hvis jeg fokuserer på dette en halvtime hver dag i noen uker bør jeg kunne komme langt. Dette vil kunne hjelpe meg å holde bedre fokus og la tankene flyte bedre mens jeg programmerer (eller mens jeg blogger for den saks skyld).

Øve, øve, øve

Jeg er ganske flink til å trene på mine programmeringsferdigheter, og det må jeg selvsagt fortsette med. I år vil jeg forsøke å fokusere litt mer på metaprogrammering, gjerne i Lisp.

Jeg vil også forsøke å øke størrelsen litt på oppgavene jeg gir meg selv, sånn at jeg får økt sjanse til å eksperimentere med ulike design-teknikker. Jeg implementerer mye algoritmer, ting som løses på 20 til 60 linjer kode, men trenger mer trening på større ting – kanskje spesielt innenfor funksjonell programmering.

En siste ting jeg gjerne vil eksperimentere mer med er arkitekturer for å gjøre systemer “scriptbare”. Embedding av Ruby, JavaScript eller lignende runtime i applikasjoner eller tjenester. Jeg har gjort litt av dette, men vil at det skal bli en helt naturlig del av verktøybeltet mitt, slik at jeg bare kan smyge det inn når behovet dukker opp.

Et større hobby-prosjekt?

Et par ganger i året bruker jeg å starte på et eller annet større prosjekt som jeg håper kan bli noe fornuftig, men som jeg likevel vet er en stør sjanse for at ikke blir noe av. Programmeringsspråket MIST er et bra eksempel fra 2011 – det var et par interessante måneder mens jeg holdt på, men jeg ser ikke for meg at jeg kommer til å fullføre planene mine nå.

Det skremmer meg likevel ikke fra å prøve igjen. Jeg har en idé til et større prosjekt nå også, noe som kan bli ganske så gøy for mange om jeg får det til. Jeg sier ikke mer enda.., vil holde kortene litt tett til brystet en stund til. Kanskje trenger jeg noen av dere som beta-testere utpå våren eller sommeren engang. Vi får se!

Konklusjon

Som vanlig har jeg mange planer og ideer om hvordan året skal bli. Jeg har noen konkrete ting jeg skal jobbe med, og spesielt skal jeg bli flinkere til å holde fokus.

Når det kommer til bloggingen så tenker jeg bare å fortsette som før – blogge når det dukker opp noe som jeg får lyst til å dele. Jeg vil gjerne lage flere videoer, for det har vært gøy. Men det er også tidskrevende, og jeg vil ikke prioritere det fremfor det andre tingene.

Nå gjelder det bare å huske på dette her. Da er det bra jeg har denne bloggposten å komme tilbake til :)

Godt Nytt År alle sammen!!!

Nå skal du få møte det jeg oppfatter som det aller mest spennende språket på .NET-plattformen for tiden. Nemerle er som en krysning mellom C# og F#, med Lisp-lignende makro-støtte som en ekstra bonus. Her har du et veldig kraftig verktøy hvor du kan programmere imperative-, objektorienterte- og funksjons-baserte løsninger proppfulle av meta-features. Eller som hjemmesiden sier, et <<Programming language for “special forces” of developers>>.

Versjon 1.0.0 ble lansert i mai i år, men arbeidet med språket startet så langt tilbake som i 2003. Programmeringsspråk skapes ofte av én person, enten som noe han gjør privat eller med backing av et firma som f.eks. tidligere Sun eller Microsoft. Andre ganger står det en kommité bak, men det resulterer sjelden i noe bra. Nemerle derimot er skapt av en gruppe utviklere ved University of Wroclaw i Polen, og deres innsats er imponerende.

(At flagget på roboten ble russisk var en glipp.., sorry! Det skulle selvsagt vært det polske.)

Nemerle er sterkt typet, og har kraftig type inference. Utviklere med bakgrunn fra språk som Java eller C# vil kunne kjenne seg igjen, men språket har også mange egenskaper hentet fra funksjonell programmering som tail call optimization, pattern matching, algebraiske datatyper, partial application, tupler osv.

Du finner også såkalte Computation expressions, som så langt jeg har forstått er det samme som monader.

Videre støtter Nemerle streng-interpolering, noe som ikke er vanlig i statisk typede språk. Det har støtte for LINQ, og du kan benytte deg av aspect-oriented programming (AOP). Dessuten har det XML literals, noe du også finner i språk som Scala og Visual Basic .NET.

Generelt sett er språket proppfullt av features, og det virker som om de er satt sammen på en meget behagelig måte. For å vise at Nemerle er et allsidig språk har jeg laget fire løsninger på Euler-oppgaven…

En imperativ løsning

La oss først se hvordan et Nemerle-program ser ut, og om vi kan gjøre “vanlig”, imperativ programmering i dette språket.

Nemerle-program består av klasser og/eller moduler (moduler er som statiske klasser). Et program må ha en Main-metode for å kunne kjøres. Merk at using-statements (import av navnerom) er utelatt fra eksemplene.

10 module Program
11 {
12     Main() : void
13     {
14         mutable sum = 0;
15 
16         for (mutable n = 1; n < 1000; n++)
17             when (n % 3 == 0 || n % 5 == 0)
18                 sum += n;
19 
20         WriteLine(sum);
21     }
22 }

I dette eksempelet opprettet jeg en sum-variabel som det er lov å endre (mutable). Nemerle finner selv ut at dette er en integer. Så kjører jeg en for-løkke, gjør en test, og legger tallet til sum om testen var positiv. Ganske rett frem dette her.

Jeg brukte “when” til testen, fordi “if” krever en else-blokk. Det er vanlig med påkrevd else i funksjonelle språk – Clojure er et eksempel på et språk som har det samme skillet.

Range, filter og fold med Labdas

Men la oss glemme for-løkken.., den er så gammeldags! Her følger en såkalt stream-basert løsning hvor jeg oppretter en range, filtrerer den, og til slutt aggregerer summen med FoldLeft.

23 module Program
24 {
25     Main() : void
26     {
27         def numbers =
28             NList.Filter ($[1..999], fun (n) { n % 3 == 0 || n % 5 == 0 });
29 
30         def result = NList.FoldLeft (numbers, 0, fun (n, acc) { acc + n });
31 
32         WriteLine(result);
33     }
34 }

Dette illustrerer først og fremst hvordan lambda-uttrykkene ser ut i Nemerle. Ellers har du jo sett denne løsningen ganske mange ganger nå.

Nøstede funksjoner og pattern matching

En ting Nemerle skiller seg litt fra endel andre språk på er muligheten til å definere funksjoner inne i andre funksjoner. I den følgende løsningen har jeg opprettet to funksjoner inne i Main-metoden. Disse bruker pattern matching og rekusjon til å finne summen – en teknikk du også så meg bruke i F#.

35 module Program
36 {
37     Main() : void
38     {
39         def include(n)
40         {
41             n % 3 == 0 || n % 5 == 0
42         }
43         def euler1(n, sum)
44         {
45             | (1000, _)              => sum
46             | (_, _) when include(n) => euler1(n+1, sum+n)
47             | (_, _)                 => euler1(n+1, sum)
48         }
49         WriteLine(euler1(0, 0));
50     }
51 }

List comprehension

Den enkleste løsningen har jeg likevel spart til slutt. Nemerle har støtte for list comprehensions, som er et kraftig verktøy for å opprette filtrerte serier. Jeg kan dermed skrive ut svaret med en ganske leselig one-liner.

52 module Program
53 {
54     Main() : void
55     {
56         WriteLine($[x | x in [1..999], x % 3 == 0 || x % 5 == 0].Sum());
57     }
58 }

Hvorfor bruke tid på Nemerle

Nemerle er et praktisk og godt verktøy som lar deg kombinere objektorientering og funksjonell programmering. I tilleg har du makroene som lar deg utvide syntaksen og kompilatoren ganske enkelt. Nemerle vil derfor egne seg svært godt til å redusere mengden “boilerplate” i større løsninger, og til å lage interne DSL’er.

Sammenlignet med F# er Nemerle trolig enklere å forstå og å komme igang med for programmerere som ikke har vært eksponert for ML-lignende språk tidligere. Nemerle’s minner nemlig mer om C# gjennom bruk av krøllparanteser, klasser og andre syntaks-elementer. Man kan begynne med objekter om man er vandt til det, og gradvis ta i bruk de andre egenskapene etterhvert som man lærer.

Hvordan komme igang

Nemerle er støttet gjennom en extension i Visual Studio 2008. 2010-støtten er i beta, men fungerte greit nok for meg. Man får farger, IntelliSense, designtime hints og sikkert andre features jeg ikke har oppdaget. Du finner også støtte for Nemerle til SharpDevelop (om du er på Linux, eller foretrekker open source).

Jeg tror det vil være svært enkelt for et team med C#-utviklere å konvertere til å bruke Nemerle. Man kan selvfølgelig bruke språket på enkeltdeler; .NET-løsninger kan fint blande prosjekter skrevet i ulike språk. Men med Nemerle kan man i tillegg inkludere C#-kode i Nemerle-prosjekter – noe lignende har jeg aldri sett før.

Dessuten tilbyr Nemerle-teamet en C#-til-Nemerle converter. Hva med å kjøre den på din eksisterende kodebase, og se hva som kommer ut i andre enden?

Du finner Nemerle på nemerle.org. Språket har også en brukbar wiki med ganske mye informasjon, linker til API-dokumentasjon og tutorials.

Som sagt synes jeg Nemerle er et veldig spennende språk, og jeg anbefaler deg å ta det i nærmere ettersyn!

I den oppkommende adventskalenderen, hvor jeg hver dag frem til Jul vil introdusere deg for et nytt programmeringsspråk, har jeg valgt én bestemt oppgave for å vise frem språkene – nemlig den første og enkleste oppgaven på Project Euler.

Oppgaven lyder:

Hvis vi lister opp alle naturlige tall under 10 som er multipler av 3 eller 5 så får vi 3, 5, 6 og 9. Summen av disse er 23. Finn summen av alle multipler av 3 eller 5 under 1000.

Jeg bruker denne oppgaven som min Hello, World når jeg lærer meg nye språk. Den sørger for at jeg raskt lærer meg flere grunnleggende byggestener i språket, som hvordan man itererer, og hvordan man tar avgjørelser basert på numeriske operasjoner.

Jeg har også brukt oppgaven her på bloggen tidligere, i posten Parallellisering av en algoritme i Erlang. I dag gir jeg deg mulighet til å gjøre deg kjent med oppgaven, og viser noen implementasjoner i de språkene du normalt ser på programmeringsbloggen.

Løsning i C#

C# er språket jeg bruker til daglig, så det er et greit sted å begynne. Her følger en komplett løsning som looper gjennom alle tallene opp til 1000, sjekker om de er multipler av 3 eller 5 (ved å bruke modulo), og summerer opp tallene i sum-variabelen. Det siste som skjer er at tallet skrives ut.

10 class Program
11 {
12     static void Main()
13     {
14         int sum = 0;
15         for (int i = 0; i < 1000; i++)
16             if (i % 3 == 0 || i % 5 == 0)
17                 sum += i;
18         System.Console.WriteLine(sum);
19     }
20 }

Som sagt er det en meget enkel oppgave – så sant du kjenner til modulo da.

En alternativ måte å løse oppgaven er å bruke en funksjonell, stream-basert teknikk. I .NET vil dette si Linq. Her er en løsning i C# som bruker Range, Where og Sum:

10 using System.Linq;
11 
12 class Program
13 {
14     static void Main()
15     {
16         System.Console.WriteLine(
17             Enumerable.Range(1, 999)
18             .Where(i => i % 3 == 0 || i % 5 == 0)
19             .Sum());
20     }
21 }
22 

I julekalenderen vil du komme til å se en god mix av disse to fremgangsmåtene, og noen som er helt anderledes.

Løsning i Ruby

Ruby er det språket det er lettest for meg å hoppe inn i om jeg skal lage et kjapt lite verktøy, skal teste ut en algoritme eller noe lignende. Her følger en imperativ løsning:

1 sum = 0;
2 (1...1000).each do |i|
3   sum += i if i.modulo(3) == 0 or i.modulo(5) == 0
4 end
5 puts sum

I Ruby bruker jeg omtrent aldri vanlige for-løkker – å opprette en range, og så kjøre en kodeblokk for hvert element er mere naturlig.

En stream-basert løsning er mere elegant. Da bruker jeg select for å filtrere tallene, og reduce for å summere, slik som dette:

7 puts (1...1000).
8   select{|x| x.modulo(3) == 0 or x.modulo(5) == 0}.
9   reduce(:+)

Løsning i Clojure

Clojure er fortsatt favorittspråket mitt, så jeg må ta med noen løsninger i det også. Selv om det er helt unaturlig å bruke en løkke i Clojure så har jeg kokt sammen en slik løsning for denne ene gangens skyld:

 1 (loop [sum 0, numbers (range 1000)]
 2   (if (seq numbers)
 3     (let [i (first numbers)]
 4       (if (or (zero? (mod i 3))
 5               (zero? (mod i 5)))
 6         (recur (+ sum i) (rest numbers))
 7         (recur sum (rest numbers))))
 8     (println sum)))

Det fungerer, men jeg gremmes! I Clojure er stream-basert programmering det naturlige, og jeg kan bruke range, filter og reduce til å løse oppgaven ganske enkelt:

 1 (println
 2   (reduce +
 3           (filter #(or (zero? (mod % 3))
 4                        (zero? (mod % 5)))
 5                   (range 1000))))

Det er derimot ikke sikkert du synes det er så enkelt å lese denne koden. Trikset med å lese Clojure/Lisp-syntaks er som følger: Skann raskt med øynene fra venstre mot høyre til du kommer til uttrykkets siste del, som i dette tilfellet er (range 1000). Arbeid deg så tilbake mot høyre.

For å gjøre koden litt mere leservennlig tilbyr Clojure deg å gjøre det samme på følgende måte:

10 (->> 1000 range
11      (filter #(or (zero? (mod % 3))
12                   (zero? (mod % 5))))
13      (reduce +)
14      println)

Denne koden kan leses fra venstre mot høyre. “Ta tallet 1000, og lag en range av det. Filtrer med en anonym funksjon som sjekker om tall er delelig på 3 eller 5. Reduser med pluss (altså pluss dem sammen), og skriv til slutt ut”.

Løsning i Common Lisp

Og helt på tampen tar jeg med en løsning i Common Lisp – fordi man der finner den kuleste og mest komplette varianten av en for-løkke som finnes i noe språk, nemlig loop makroen:

1 (print (loop for x below 1000
2              when (or (zerop (mod x 3))
3                       (zerop (mod x 5)))
4              sum x)

Du har nå sett oppgaven løst med fire ulike språk, og i desember vil du få se flere løsninger. Da vil jeg sansynligvis bryte oppgaven opp i flere steg eller funksjoner, slik at jeg får presentert enda flere aspekter ved språkene jeg forteller om.

Jeg håper du gleder deg like mye som meg :)

En nerd må ha noe å gjøre på. Så i sommer begynte jeg å implementere et nytt programmeringsspråk. Jeg har valgt å kalle det Mist!

Navnet ble valgt før jeg ble gjort oppmerksom på at det på tysk betyr gjødsel (for å si det pent).

Mist skal være et general purpose, dynamisk språk med fokus på den funksjonelle programmeringsparadigmen, og tilhører Lisp-familien. Det kjører på .NET-plattformen, og er implementert i C#.

Hvorfor?

Jeg begynte på dette for å lære, og for å ha det gøy. Alle utviklere med noen år på baken og respekt for seg selv burde vite hvordan man bygger et språk, og den eneste måten å kontrollere at man vet hvordan er å gjøre det.

Følelsen jeg hadde da jeg f.eks. implementerte rekursjon, eller da jeg fikk til closures, var helt hærlig. Følelsen litt senere av å forstå at jeg hadde løst scopes feil (etter å ha lest litt i Structure and Interpretation of Computer Programs), for så å rette det opp slik det burde være, var enda bedre. Jeg har allerede lært mye av dette, selv om jeg er LANGT FRA FERDIG.

Kan det brukes til noe?

Mist kommer ikke til å bli det neste, store språket som alle kommer til å ville bruke. Det kommer ikke til å kunne konkurrere med for eksempel Clojure. Men kanskje finnes det en liten nisje hvor Mist kan komme til nytte? Selv om jeg gjør dette for å lære og å ha det gøy, så har jeg i alle fall tenkt å holde på til jeg har et “ferdig” språk som kan tas i bruk av andre enn meg selv.

Mist kan brukes på flere måter; spåket er implementert i form av en høy-nivå tolker som består av én enkelt .NET dll. Denne kan refereres direkte i .NET-prosjekter for å gjøre dem “skriptbare”. Jeg har også laget en enkel Read-Eval-Print Loop hvor man interaktivt kan eksperimentere med Mist-kode, eller laste og kjøre Mist-filer.

Som en tredje opsjon har jeg tenkt å tilby en slags kompilator som tar en eller flere Mist-filer som input, og genererer en “standalone” exe-fil.

Noen betraktninger

Når man skal implementere dynamiske språk på .NET-plattformen kan det være naturlig å basere seg på Dynamic Language Runtime. Det valgte jeg derimot å ikke gjøre. Jeg ville lære mest mulig som jeg kan benytte uavhengig av plattform, og ikke bruke tid på å sette meg inn i et biblotek hvor deler av jobben allerede er gjort.

Det finnes forøvrig mange beskrivelser på nett og andre steder av hvordan man implementerer Lisp-lignende språk. Jeg valgte å ikke studere disse – mitt fokus var igjen å bruke og lære generelle teknikker for å utvikle parser, tolker og/eller kompilator (hovedinspirasjonen til prosjektet er boken Language Implementation Patterns – og så trekker jeg på det jeg allerede kan om Clojure, Scheme og Common Lisp).

Ved første øyekast ser Mist ut som en hvilken som helst Lisp-implementasjon, men det skiller seg nok litt fra de fleste andre likevel. Blant annet har jeg valgt å ikke basere liste-strukturene på såkalte cons-par. I stedet bruker jeg listene i .NET basebibloteket.

Det er også vanlig at store deler av språk i Lisp-familien implementeres i språket selv. Mist består derimot av ganske mye C# – dette er for å utnytte det som allerede finnes i .NET, blant annet i et håp om å gjøre koden raskere enn jeg ellers ville klart.

Veien videre

Men det er tidlig enda. Jeg ser for meg at jeg skal jobbe med Mist – på bussen, fergen, og på kveldstid – i et par måneder til før jeg har noe som kan kalles en beta. Og estimater er til for å sprekke!

Av ting som jeg gleder meg til å gå igang med nå kan jeg nevne reader-macros, syntax quoting og tail call optimalisering. Når det gjelder tail calls så har jeg en ide om at jeg kan løse det med contiuation passing, men jeg må nok gjøre litt mer research før jeg er sikker på hvordan det skal gjøres.

Jeg har også planer om en dyp integrasjon med .NET (bruke .NET-typer fra Mist) som vil skille seg endel i fra hvordan f.eks. Clojure er integrert med Java. Med det gjenstår å se om det lar seg realisere.

Er du interessert i å ta en titt på koden, eller laste det ned og ta Mist på en liten kjøretur, så finner du prosjektet på Github. Bedre dokumentasjon på bruk og API kommer etterhvert.

Er du hekta på spill? Digger du å samle poeng og “badges”? Er du alltid nødt til å vinne, og gjør alle situasjoner om til en konkurranse? Den egenskapen kan du bruke til å bli en bedre programmerer!

Det finnes nemlig mange steder hvor man kan bruke sin programmeringskunnskap til å konkurrere, og å få verdifull erfaring på kjøpet. Blant de mest populære sitene har vi f.eks. StackOverflow, som i praksis har tatt helt over den rollen som internett-forumene hadde for noen år siden. Hvis du er flink kan du svare på spørsmål, hvis du ikke er så flink kan du stille spørsmål. Og samme hva du gjør så får du poeng, låser opp nye ting du kan gjøre, og samler badges i gull, sølv og bronse. Jeg tror de fleste ble ganske overrasket da de så hvor avhengighetsskapende dette faktisk var.

Og ikke glem at StackOverflow har en haug med datter-sites som kan være like interessante, som for eksempel programmers.stackexchange.com, som er mere diskusjonsorientert, codereview.stackexchange.com, hvor du kan få folk til å vurdere koden din, og codegolf.stackexchange.com, som handler om programmeringsoppgaver og konkurranser. Det finnes egne varianter for spillutvikling, brukeropplevelse, QA-prosessen osv.

Code Golf er forresten et begrep som betyr å konkurrere om å lage det minste programmet som løser et gitt problem. Det finnes et hav av sider dedikert til denne formen for programmering. Et eksempel er phpGolf.org, som er utviklet av noen norske entusiaster. Utviklere interessert i Clojure kan prøve seg på 4Clojure.

Et annet sted jeg har tilbrakt endel tid er Euler Project. Her er det et hav av oppgaver man kan løse i valgfritt språk / verktøy. Også her blir man rangert, der er ulike nivåer man kan oppnå, og man får et badge man kan bruke til å skryte til omverdenen.

Coderwall er en ganske fersk site som utelukkende baserer seg på at folk vil vise seg frem, at de er stolte av hva de gjør, og at det er gøy å samle på “speidermerker” (evt. russeknuter). Siten kobler sammen og analyserer kontoer du har andre steder – som github og codeplex – og gir deg merker basert på hva du faktisk har oppnådd.

Betydningen av å leke og å ha det morro skal ikke undervurderes. Vi lærer lettere når vi har det gøy – dette viser både sosial og neural forskning – og konkurranseelementet stimulerer oss til å stå på og ikke gi opp.

Å bruke tid på disse sitene er derfor positivt for din utvikling som programmerer. De kan holde interessen din oppe over lengre tid, de kan eksponere deg for mange ulike oppgaver du må tenke gjennom, og ikke minst de setter hjernen din i en modus hvor den lærer bedre. At vi lærer mest av våre feil er en myte – det er mange, små suksesser som gjør deg til en bedre utvikler!

Legg igjen en kommentar om du har du tips til andre programmeringskonkurranser eller sites/communities som stimulerer deg på denne måten…

Første dag på NDC 2011 er vell overstått. Jeg har fått med meg en god blanding av ulike foredrag som nå må fordøyes før det braker løs igjen i morgen tidlig.

.NET Ninja quizen på standen vår har også vært flittig besøkt. Men det er ikke mange som når helt opp – såvidt jeg vet var det bare kollega Henrik som klarte alle femten spørsmålene i dag, og han fikk strengt tatt hjelp på ett av dem.

Vi hadde Uncle Bob innom også; han hadde ikke tid til å prøve spillet, men sa han skulle komme tilbake. Så hvis du leser dette og deltar på konferansen, så må du komme innom du også, smake på kaffen, og prøve deg på quiz. Kanskje blir du en av ytterst få som kan skyte av å være en .NET Ninja!

I dag brukte jeg førsterangs funksjoner (first-class functions) i C# på en måte jeg følte det var verdt å skive en liten blogpost om. Jeg bruker lambda-uttrykk til mye rart hele tiden, men jeg kan faktisk ikke huske at jeg har brukt Funcs til å referere til metoder på objekter før.

Jeg skulle bruke et tredjeparts API hvor jeg skulle kalle en av to ulike metoder avhengig av en boolsk tilstandsvariabel. Metodene hadde mange parametre, men signaturen var lik på begge. Her er hvordan koden først så ut (navnene er endret for å “beskytte de skyldige”):

10 private CustomerInfo CreateOrRemove(FooWebService client,
11                                     int customerId,
12                                     string phoneNumber,
13                                     bool create)
14 {
15   if (create)
16     return client.CreateFoo("some constant",
17                             customerId,
18                             phoneNumber,
19                             string.Empty,
20                             this.someField,
21                             string.Empty,
22                             this.someOtherField);
23   else
24     return client.RemoveFoo("some constant",
25                             customerId,
26                             phoneNumber,
27                             string.Empty,
28                             this.someField,
29                             string.Empty,
30                             this.someOtherField);
31 }

Det er det at metodene tar 7 parametre som gjør koden stygg. En bedre løsning hadde selvfølgelig vært å bruke ett objekt som inneholdt de syv variablene som argument til metodene – men med tredjeparts API’er kan man ikke alltid få det som man vil.

Men jeg hater denne typen kodeduplisering. I gamledager hadde jeg latt koden forbli som dette, men etter å ha jobbet mye i funksjonelle språk i det siste er det derimot en simpel sak å fikse på problemet. Jeg var ikke helt sikker på om C# sin Func støttet det jeg ville, men det funket heldigvis helt fint (pun intended):

33 private CustomerInfo CreateOrRemove(FooWebService client,
34                                     int customerId,
35                                     string phoneNumber,
36                                     bool create)
37 {
38   Func<string, int?, string, string, string, string, string, CustomerInfo> operation;
39 
40   if (create)
41     operation = client.CreateFoo;
42   else
43     operation = client.RemoveFoo;
44 
45   return operation("some constant",
46                    customerId,
47                    phoneNumber,
48                    string.Empty,
49                    this.someField,
50                    string.Empty,
51                    this.someOtherField);
52 }

Det er ikke akkurat vakkert å spesifisere funksjonssignaturen på denne måten, men det gjør jobben – dupliseringen er borte, og koden kommuniserer faktisk litt bedre hva den gjør (etter min mening).

Trekker jeg ut valget av create/remove i en egen metode blir det enda bedre:

54 private static Func<string, int?, string, string,
55         string, string, string, CustomerInfo>
56         GetOperation(FooWebService client, bool create)
57 {
58   if (create)
59     return client.CreateFoo;
60   else
61     return client.RemoveFoo;
62 }
63 
64 private CustomerInfo CreateOrRemove(FooWebService client,
65                                     int customerId,
66                                     string phoneNumber,
67                                     bool create)
68 {
69   return GetOperation(client, create)("some constant",
70                                       customerId,
71                                       phoneNumber,
72                                       string.Empty,
73                                       this.someField,
74                                       string.Empty,
75                                       this.someOtherField);
76 }

Så det var altså dagens mest spennende kode. Har du gjort noe spenstig med Funcs i det siste? Del dine erfaringer da vel!

Jeg føler for å oppsummere uken som har gått. Har behov for å skrive litt dagbok liksom. Skrive litt om hva som har skjedd, “dumpe” noen av tankene jeg går rundt med, og fortelle hva jeg har gjort for å bli en bedre utvikler denne uken.

Jeg tenker jeg vil forsøke å gjøre det hver uke fra nå av. Hvis jeg er skikkelig heldig kan det bli interessant for andre enn meg selv også. So here we go…

Regresjonstesting

Denne uken har jeg testet ut Selenium – det mest kjente og brukte rammeverket for automatisert testing av webgrensesnitt. Jeg har satt opp et opplegg for å teste Intouch (vår komplette webløsning for SMS) – en serie med tester som kjøres hver natt av vår TeamCity buildserver. Jeg bruker .net-versjonen av Selenium 2.0 WebDriver, og valgte å kjøre testene i Firefox 4 (hadde diverse problemer med både Chrome-driveren og IE-driveren).

Jeg holdt en liten ZipTalk for de andre på teknisk, og jeg tror alle var enige med meg i at automatiserte regresjonstester var noe vi trengte. Spørsmålet nå er hvilke tester vi skal ha, og hvordan vi best skal få implementasjonen av disse testene inn i utviklingsløpet vårt. Jeg ser i utgangspunktet ikke på dette som noe som skal inngå i testdreven utvikling, derimot tror jeg det er best å skrive testene når funksjonaliteten som skal testes har stabilisert seg. Kanskje kan det gå inn som en del av QA-fasen.

.Net 4.0 og Visual Studio 2010

Denne uken har teamet vårt også endelig tatt steget over på nyeste versjon av .net-rammeverket. Og det ser ut til å ha gått ganske smertefritt egentlig.

Men .net 4 er bare én av en hel rekke nye teknologier vi forholder oss til for tiden – av andre ting vi har tatt i bruk i det siste kan jeg nevne MongoDB og seriøs utnyttelse av jQuery. Og mye nytt og ukjent kan gi en følelse av manglende mestring og føre til stress. Derfor har jeg bestemt at vi skal ha en ZipTalk-serie om nye ting i .net 4.0. Utviklerne har nå valgt seg ut hver sine områder å utforske og presentere for teamet, og jeg venter spent på resultatet.

Og ellers…

På fritiden har jeg lest endel i de to bøkene jeg snakket om her: Metaprogramming Ruby og Pragmatic Thinking & Learning. Jeg har fått en dypere forståelse for hvordan Ruby egentlig fungerer – språket er både fantastisk komplekst og ekstremt elegant på en og samme tid. Og jeg har fått et bedre innblikk i hvordan menneskehjernen fungerer, hvorfor jeg tenker som jeg gjør, og noen verktøy for å påvirke og forhåpentligvis forbedre hvordan jeg tenker og løser problemer.

Jeg har også rukket å løse noen Euler-oppgaver, og er nå oppe i 29 løste (av i alt 332). Jeg har brukt Clojure, som fortsatt er det mest elegante språket jeg har vært borti noen sinne, og det faller meg mer og mer naturlig å løse oppgaver med funksjonell programmering. Derfor har jeg også bestilt en ny bok – The Joy of Clojure – som virker svært lovende.

Jeg har gått og tenkt på og hatt lyst til å skrive et par blogposter også denne uken – en om Dreyfus-modellen og hvor jeg befinner meg i den i ulike ferdigheter, og en om funksjonell programmering. Men tiden har sålangt ikke strukket til. Jeg har vært på et par årsmøter også denne uken nemlig; i sameiet og i NNUG Bergen.

Ukens sitat

Jeg kommer hele tiden over mange gode sitat jeg får lyst til å dele med verden. I forbindelse med at jeg nettopp har fylt 35 presenterer jeg denne gang et Douglas Adams-sitat fra The Salmon of Doubt:

“Anything that is in the world when you’re born is normal and ordinary and is just a natural part of the way the world works. Anything that’s invented between when you’re fifteen and twenty-five is new and exiting and revolutionary and you can probably get a career in it. Anything invented after you’re thirty-five is against the natural order of things.”

Det er mye visdom i dette sitatet, men jeg håper jeg kan motarbeide det og fortsette å utvikle meg i årene som kommer.

For en gangs skyld skal jeg poste noen andres kode her på bloggen. Jeg har nemlig kommet over et lite stykke C#-kode som jeg syntes var verdt litt ekstra oppmerksomhet. I vinter brukte vi i PSWinCom et rammeverkt som heter OpenRasta til å implementere et REST-API for vårt Intouch-produkt. OpenRasta er et open source-prosjekt utviklet av Sebastian Lambla, og det var her jeg oppdaget en mildt sagt spesiell utnyttelse av C#.

Du kan jo bedømme selv…

10     public class OperationResultPage : Element
11     {
12         public OperationResultPage(OperationResult result)
13         {
14             Root = this
15                 [html
16                      [head[title[result.Title]]]
17                      [body
18                         [h1[result.Title]]
19                         [p[result.Description]]
20                      ]
21                 ];
22         }
23 
24         protected Element Root { get; set; }
25     }

Når du ser koden for første gang tar det noen sekunder før hjernen aksepterer at det er C#-kode du ser på.

Gjennom serdeles ukonvensjonell bruk av C# har Sebastian rett og slett laget en ganske så fasinerende DSL for å definere HTML-markup. Det minner en god del om (og er helt sikkert inspirert av) tilsvarende DSL’er i mere dynamiske språk – som f.eks. Hiccup i Clojure.

Her er et par utdrag fra den abstrakte klassen OpenRasta.Web.Markup.Elements.Element, som kaster litt mer lys over hvordan koden kombinerer bruk av indeksere og properties for de ulike HTML-taggene til å kjede sammen markup på en helt nye måte.

 47         protected Element this[INode child]
 48         {
 49             get
 50             {
 51                 ChildNodes.Add(child);
 52                 return this;
 53             }
 54         }

..og..

 96         public IHtmlElement html
 97         {
 98             get { return Document.CreateElement<IHtmlElement>(); }
 99         }

Sebastian er en dyktig utvikler med smittsomt humør og pipete stemme som i tillegg til OpenRasta akkurat nå er kjent for prosjektet OpenWrap, et “pakkehåndteringssystem” for .NET (ala gems for Ruby). Jeg vet ikke om det er Sebastian som har kommet opp med denne DSL-teknikken, eller om det er noe du kan finne andre steder også, men det er liten tvil om at fyren er genial.

Så vil jeg bare avslutte med å foreslå en aktivite som garantert vil gjøre deg til en bedre utvikler: Les mer kildekode! Det finnes et hav av prosjekter der ute som du kan lære av. Hvorfor ikke begynne med OpenRasta for eksempel?!

For dem som har litt tid til overs i romjulen presenterer jeg her inteessante linker jeg har samlet på i året som gikk.

Interessante blogposter og andre websider

Jeg har ikke fulgt like nøye med i blogsfæren i år som jeg gjorde i 2009, og mange av de linkene jeg har funnet mest interessante er heller ikke ting som er skrevet i fjor. Et par blogger jeg likevel har fulgt nøye med på er to norske programmeringsblogger, med folk fra to av norges fremste konsulenthus. Jeg snakker om Sterk Blanding og BEKK OPEN.

Andre linker jeg vil anbefale: Scenario Driven Tests (Ayende Rahien) | The Tortoise and the Hare (Robert C. Martin) | Teach Yourself Programming in Ten Years (Peter Norvig) | Create a Language Compiler for the .NET Framework | Nifty Assignments fra stanford.edu (gode ideer til programmeringsoppgaver) | Agile Skills Project Wiki | Literate Programs (en wiki hvor artiklene er både et dokument og kode som kan lastes ned, kompileres og kjøres).

Og til slutt anbefaler jeg å lese denne eposten fra Alan Key, hvor han snakker om objektorientering og “messaging”.

Interessante videoer

Jeg har sett mange foredrag og intervjuer på InfoQ i år. Her er noen av de mest spennende: Brian Foote and Dave West Discuss Craftsmanship | Exploring Dynamism | Radical Simplification Through Polyglot and Poly-paradigm Programming | Responsive Design med Kent Beck | Paneldebatt om Future of Programming Languages.

Ellers finnes det mange, gode presentasjoner fra NDC 2010 her, og er du interessert i Clojure kan jeg anbefale Full Disclojure-kanalen på vimeo. Og sist men ikke minst, om du ikke har sett den allerede så bare må du ta en titt på Erlang: The Movie.

Bøker du kan lese på nettet

Her er tre forskjellige bøker jeg har tenkt å lese – har bare ikke kommet så langt. Den første er den populære Getting Real fra 37signals. Du kan lese den på nettet, eller kjøpe den enten som PDF eller i dødt tre. Den neste er Peter Seibels Practical Common Lisp, en god bok for dem som vil lære seg det språket. Og til slutt en online bok/tutorial som heter Learn You a Haskell for Great Good, som jeg skal lese når jeg får lyst til å se på Haskell igjen.

software

I løpet av et år tester jeg ut ganske mange rammeverk, biblotek og programmer som er mer eller mindre nyttige for meg som utvikler. Noen av de mest interessante i 2010 var: MongoDB | Reactive Extensions for .NET (Rx) | Beanstalk (a simple, fast work queue) | Gosu (a 2D game development library for Ruby and C++) | Baretail | Large Text File Viewer.

Ting jeg ikke fikk tid til å se nærmere på

RubyGame | Prawn (PDF-generering i Ruby) | GraphViz (Graph Visualization Software) | Flot (a pure Javascript plotting library for jQuery) | Twibot (Ruby twitter bot framework) | TreeTop (et språk for å beskrive språk) | Inno Setup | Google Prediction API | nSubstitute (a friendly substitute for .NET mocking frameworks – se også Fake It Easy) | AutoBuildTool (a continuous testing tool for .NET) | TrueStory (Agile tool, mulig alternativ til AgileZen).

Dessuten syntes jeg denne siden var kul, og jeg fikk lyst til å lage noe sånt selv. Siden er rett og slett en kommandolinje laget i javascript.