Livet vendt på vrangen og med nye udfordringer

by DotNetNerd 25. April 2008 22:12

Som livet dog pludselig kan blive vendt på hovedet 

Den sidste 1½ måned har været en rimelig stor omvæltning i mit liv, på både godt og ondt. Min kæreste og samlever igennem henholdsvis 4 og 3 år valgte at forlade mig, så pludselig fra den ene dag til den anden blev mig privatliv vendt på hovedet. Jeg vil ikke blotlægge mit blødende hjerte her på bloggen, men det skal nævnes da det har været en del af en masse forandringer der er sket på det seneste.

Heldigvis har arbejdet budt på andetledes positive tiltag, da jeg har fået ansvar for kvalitetssikring og herunder altså standardisering, tests og dokumentation. Det er nogle områder jeg glæder mig meget til at kunne fokusere mere på i den næste tid, samtidig med at jeg håber at kunne komme igang med Silverlight for alvor når nu version 2 kommer på gaden her en af de næste måneder.

F# præsentation for Aarhus .NET UserGroup

Som direkte konsekvens af at jeg var månedens blogger i marts, har jeg modtaget en henvendelse fra ANUG.dk, som gerne vil have mig til at lave en præsentation omkring F# til september. Det er helt sikkert også noget jeg ser frem til, da jeg længe har haft lyst til at prøve kræfter med at lave præsentationer/foredrag. Jeg tror det bliver rigtigt spændende og håber at både tilhørerne og jeg selv får en masse ud af det. Det er ihvertfald et emne jeg selv synes er enormt interessant for fremtiden, og så kan man da også håbe at kunne udvide sit netværk i den forbindelse.

Løbesæson

For godt et år siden blev jeg logget til at deltage i DHL staffetten 2007, selvom jeg aldrig havde tænkt så meget på at begynde at løbe. Pre foråret 2007 sagde jeg altid at jeg ikke løb med mindre der var nogen efter mig, og selv der var det tvivlsomt om jeg egentlig gad :) Det viste sig imidlertid at jeg blev lidt bidt af det - så nu er det en motionsform jeg nyder at kombinere med at træne i motions center. Jeg er afgjort kun hyggeløber, idet jeg begrænser min "løbesæson" til at være nu her imens vejret er rart, og på den måde håber jeg også at undgå at køre træt i det. I næste uge er det så eventyrløbet jeg vil prøve at kaste mig ud i, og jeg håber at få bedre vejr til det end tilfældet var sidste år til staffetten hvor det var regnvejr og bidende koldt.

Tags:

Andenplads ved E-handelsprisen 2008 og FLOT fremskridt

by DotNetNerd 27. March 2008 21:25

Andenplads ved E-handelsprisen 2008

Idag blev e-handelspisen for 2008 uddelt, hvor byggecity.dk som vi har udviklet var nomineret, hvilket vi allerede var glade for. Derudover blev det til en flot 2. plads i kategorien nystartere. Det er et projekt vi fortsat ser frem til at arbejde videre med, og hvor vi har nogle spændende initiativer i støbeskeen, så at det allerede har fået sådan en erkendtlighed er bestemt en behagelig overraskelse.

FLOwerTracker

I fritiden skrider det desuden også fremad med mit FLOwer Tracker projekt, som har fået egne domæner på flowertracker.dk og flowertracking.dk. I samme ombæring blev sitet flyttet til min egen virtuelle server, som jeg er blevet rigtigt glad for (solarvps.com). Projektet som sådan er også blevet udvidet en anelse, med udvidede muligheder for data udtræk, så det begynder efterhånden at ligne et mere komplet produkt - selvom der er passer af udvidelser på vej.

JoelOnSoftware om browserkompatibilitet

Joel har igen begået et fantastisk blogindlæg, hvor jeg synes han virkelig rammer sømmet på hovedet. Denne gang er det omkring hele den her browser krigszone som vi udviklere står midt i, og alt for mange vælger at udtale sig om uden rigtigt at have forstået problemet. Indlægget kan læses her: http://www.joelonsoftware.com/items/2008/03/17.html

Tags:

F# og imperativ programmering

by DotNetNerd 19. March 2008 23:50

Som jeg tidligere har nævnt er en af de helt store styrker ved F# at det giver mulighed for at kombinere forskellige stilarter, og jeg skylder derfor at runde imperativ programmering, som nok i virkeligheden er den programmeringsform de fleste udviklere er bekendt med.

Imperativ betyder påbud og inden for grammatik er det den form at et verb vi på dansk kalder bydeform (eks. "syng!"). Imperativ programmering vil derfor sige programmering hvor ens statements går på "hvordan" en opgave løses, hvorimod funktionel programmering handler mere om "hvad" der skal gøres.

Selvom F# i udgangspunkt er et funktionelt sprog der søger at få folk til at bruge immutable datastrukturer, kan det nogen gange være mere intuitivt at arbejde med imperative statements som loop strukturer og mutable data. Der kan selvfølgelig også nogen gange være en masse performance at hente ved ikke at skabe en masse objekter men istedet blot ændre en værdi.

Looping and iterating over data

Et helt basalt loop ligner noget man kender fra andre sprog og ser ud som herunder.

let PrintValues1To10 =
  for i = 0 to 10 do
    printfn "Value: %d" i

PrintValues1To10

På samme måde kan man desuden skrive et while loop sådan her.

let PrintNamesAndCities =
  for (name, city) in [("Christian", "Odense"); ("Henrik", "Kerteminde")] do
    printfn "%s %s" name city

PrintNamesAndCities

Mutable data og while loops

While loops som man kender dem findes naturligvis også, men disse bruges oftest sammen med mutable data hvis man tænker over det. Et typisk scenarie er at man laver en udregning og gentager denne indtil en given variabel har en værdi der tilfredsstiller et eller andet boolsk udtryk. Et eksempel på anvendelse at et while loop og mutable data kunne eksempelvis være.

let PrintWhileLessThan10 =
  let mutable i = 0
  while (i<10) do
    printfn "Value: %d" i
    i <- i+1

PrintWhileLessThan10

Det ovenstående eksempel viser den mest brugte måde at arbejde med mutable typer, men ligesom man i andre sprog kan arbejde med mutable reference typer kan man også i F# ved hjælp af keywordet ref og operatorerne ! og :=. På den måde kunne ovenstående stump kode have været skrevet sådan her, med samme overordnede resultat.

let PrintWhileLessThan10 =
  let i = ref 0
  while (!i<10) do
    printfn "Value: %d" !i
    i := !i+1

PrintWhileLessThan10

Imperative collections

Udover de datastrukturer jeg har set på tidligere her på bloggen kan man desuden også arbejde med de collection klasser der findes i .NET frameworket, som er imperative af natur. Disse collections bruges på samme vis som du sikkert er vant til men System.Collections.Generic.List<'a> bruges normalvis via aliaset ResizeArray, som er standard i F# fordi det er mere sigende for hvad strukturen er beregnet til.

let names = new ResizeArray<string>()

for name in ["Jens"; "Frans"; "Erik"] do
  names.Add(name)

printfn "Navn: %s" names.[1]

Exception raising og handling

En anden karakteristisk egenskab det går igen i imperative sprog er exception handling. Selvom det bygger på den måde exception handling fungerer på i .NET frameworket fungerer det en smugle anderledes i F#.

Hvis man vil raise en exception kan det gøres sådan her:

raise (System.InvalidOperationException("Man kan jo ikke dividere med 0 vel!"))

Der findes dog også en generel måde at raise exceptions på ved at skrive eksempelvis sådan her.

failwith "Man kan jo ikke dividere med 0 vel!"

Som medfører at en Microsoft.FSharp.Core.FailureException kastes. Den findes også i en failwithf der tager stringformat argumenter ligesom printf.
Specifikt til argument exceptions er der en forkortet udgave der kaster en InvalidArgumentException.

invalid_arg "argument må ikke have negativ værdi"

På den anden side af hegnet skal man jo også kunne håndtere exceptions. Dette fungerer som en kombination imellem en try catch som de fleste kender den og et udtryk til pattern matching.

try
  raise (System.InvalidOperationException("Fejl nu bare"))
with
  | :? System.InvalidOperationException as err -> printfn "Grebet ud: %s" err.Message

Ellers hvis man ønsker at gribe alle exceptions kan det gøres sådan her.

try
  raise (System.InvalidOperationException("Fejl nu bare"))
with
  | err -> printfn "Message: %s" err.Message

Og finally findes naturligvis også til at sørge for at ressourcer disposes korrekt - og den ligner sig selv som man kender den.

try
  raise (System.InvalidOperationException("Fejl nu bare"))
finally
  printfn "Finally kaldt"

Man kan dog ikke kombinere disse som i andre .NET sprog da en try-with-finally konstruktion ikke er understøttet, idet det ikke findes i OCaml. Det man normalt gør istedet er at bruge enten en "use" binding eller et "using" scope istedet.

let WriteToFile() =
  use output = File.CreateText(@"data.txt")
  output.WriteLine("This is nice")

 eller som using

let WriteToFile() =
  using (File.CreateText(@"data.txt")) (fun output ->
    output.WriteLine("This is nice"))

 

Tags:

F# interaktiv, pattern matching og active patterns

by DotNetNerd 23. February 2008 17:46

Interaktiv eksekvering

Interaktiv eksekvering er en feature som F# tilbyder der giver mulighed for at afvikle kode som scripts. Dette giver mulighed for at skrive kode på en behagelig måde, hvor man undgår hele tiden at skulle igennem en kode-compile-run cyklus. En almindeligt anvendt teknik er at anvende en scriptfil som "scratch pad", hvor man kan teste små stykker kode løbende.

For at udnytte dette skal man blot åbne F# interactive igennem Tools -> Add-in Manager og lave en fsx fil. Her skriver man så sin kode og når der er en del man ønsker at eksekvere markerer man den og trykker Alt + Enter. Dette gør at man meget hurtigt kan teste sin kode, uden at skulle compile, sætte et breakpoint og debugge indtil man er fremme til det sted i koden man er interesseret i.

Pattern matching

En interessant ting man kan starte ud med at prøve af - f.eks i F# interactive - er pattern matching, som er en feature der ikke er set før i .NET sprog, men som findes i andre miljøer. Pattern matching giver en meget kompakt måde at styre program flow på, lidt i stil med at bruge case sætninger i struktur, men langt mere anvendeligt og kraftfuldt.  Et super simpelt eksempel kan være at man gerne vil afvikle noget kode ud fra hvad værdi en streng har:

let value = "a"

match value with
| "a" -> printfn "The value was an a"
| "b" -> printfn "The value was a b"
| _ -> failwith "Unknown value"

Som det fremgår er syntaksen meget kompakt, og let at læse. Underscoren i den sidste linie betyder at hvilken som helst anden værdi vil blive håndteret, lidt ligesom default i en case hvis man vil sammenligne det med noget man kender fra C#/VB. En vigtig ting man skal vide er at et pattern match altid skal være udtømmende. Det vil sige at det samlet set skal kunne håndtere alle mulige værdier for at det validerer. Desuden afvikles koden ved at værdien matches imod mønstret linie for linie indtil der findes et match. Så hvis man laver et match der udelukker et efterfølgende vil man få en warning idet koden aldrig vil kunne blive ramt.

En anden anvendelse af pattern matching er til at opløst tubler som ses herunder. Nu begynder vi at komme ud i nogen scenarier der viser at pattern matching er mere anvendelige end case sætninger, og at de er stærke i samspil med funktionelle data strukturer.

let value = ("b", "a")

match value with
| ("a", "b") -> printfn "The values were a and b"
| ("b", _) -> printfn "The first value was b"
| _ -> failwith "Unknown value"

Der kan matches på mange forskellige måder men en anden meget anvendt operator :? gør det muligt at matche på typer. Her er det dog vigtigt også at bemærke at dette kræver en box operation, som der fremgår.

let value = "2"

match box value with
| :? System.Int32 -> printfn "The values was an integer"
| :? System.String -> printfn "The value was a string"
| _ -> failwith "Unknown value"

Active patterns

Active patterns er en teknik der gør det muligt at skrive mere advancerede patterns til brug sammen med mere komplekse datastrukturer eller til at lave mere komplek matching. I eksemplet herunder ses et active pattern der matcher ud fra et regular expression og returnerer en option sequence af de værdier der blev matchet ved at eksekvere det angivne regex.

let (|ParseRegex|_|) regex str =
  let regex = new System.Text.RegularExpressions.Regex(regex)    
  let matches = regex.Matches(str)    
  if matches.Count > 0 then        
    Some { for x in matches -> x.Value }    
  else        
    None

Dette active pattern kan derefter bruges på følgende måde sammen med pattern matching til eksempelvis at udskrive alle tal i en streng. Underscoren i deklerationen af dette active pattern betyder at mønstret er ufuldkomment, hvilket vil sige at det kan returnere None.

let PrintNumbers str =
  match str with
  | ParseRegex "\d" st -> Seq.iter(fun x -> printfn "Number found: %s" x) st
  | _ -> printfn "No numbers"

PrintNumbers "b123"

Alternativt kan active patterns bruges over eksempelvis discriminated unions. Et meget anvendt eksempel rundt omkring på nettet har været et discriminated union over et binært træ. Eksemplet kan ses herunder og det representerer helt enkelt et træ, hvor hvert element kan være enten en knude eller et blad - hvor knuder består af 2 elementer.

type BinaryTree<'a> =    
  | Leaf of 'a    
  | Node of BinaryTree<'a> * BinaryTree<'a>

Udfra dette kunne et active pattern eksempelvis bruges til at returnere om en XmlNode er en node eller et blad.

let (|Node|Leaf|) (node : #System.Xml.XmlNode) =    
  if node.HasChildNodes then        
    Node (node.Name, { for x in node.ChildNodes -> x })    
  else        
    Leaf (node.InnerText)

Dette kunne så bruges til at lave forskellige matches, og eksempelvis rekursivt udskrive noderne indenteret ligesom i xml dokumentet.

let PrintXml node =    
  let rec PrintXml indent node =        
    match node with        
    | Leaf (text) -> printfn "%s%s" indent text        
    | Node (name, nodes) ->            
      printfn "%s%s:" indent name            
      nodes |> Seq.iter (PrintXml (indent + "    "))    
  PrintXml "" node

Givet et xml dokument over ansatte i en lille IT virksomhed kunne man så benytte funktionen til at udskrive indholdet pænt sådan her.

let doc =    
  let xmlDoc = new System.Xml.XmlDocument()    
  let text = "
<employees>    
  <programmers>
    <junior>10</junior>
    <senior>8</senior>
  </programmers>
  <designers>3</designers> 
</employees>"
  xmlDoc.LoadXml(text)    
  xmlDoc
PrintXml (doc.DocumentElement :> System.Xml.XmlNode)

Tags:

Feed-Me.dk release og Lang.NET inspiration

by DotNetNerd 22. February 2008 19:49

Feed-me.dk release 

Det seneste års tid er jeg i stor stil røget med på rss bølgen, og er begyndt at abonnere på en række feeds for at følge med i diverse nyheder - især inden for .NET udvikling. Jeg er dog tit løbet på det problem at der er feeds som indimellem indeholder nogle virkelig interessante indlæg, men som desværre hovedsageligt drukner i personlige historier, som jeg er knap så interesseret i. Jeg har derfor nu lavet en service som jeg stiller gratis til rådighed på http://www.feed-me.dk, hvor det er mulige at sammensætte et feed der er kombineret af andre feeds, og filtreret ud fra nøgleord man indtaster som har ens interesse. Man kan desuden selv vælge om man vil have feedet i RSS eller Atom format, ved at angive dette som en del af url'en i et REST format. Eksempelvis har jeg lavet et udviklings feed som kan ses her: http://www.feed-me.dk/feed.svc/UdviklingsDemo/rss - hvor url'en viser at det sammensatte feed er navngivet UdviklingsDemo og at jeg vil se den i rss format.

Da servicen er gratis håber jeg at brugerne er så flinke at holde øje med mine google reklamer, og klikker på dem de synes er interessante, og eventuelt bruge den søgebar jeg har inkluderet i bunden. Ideen er at jeg vil give 20% af de penge jeg eventuelt tjener til kræftens bekæmpelse, idet det er en sygdom jeg selv har haft tæt inde på livet. Skulle du finde servicen interessant men synes der mangler en eller anden feature må du meget gerne skrive om dit ønske, da jeg gerne udvider den. Som det tydeligt fremgår af siden er jeg ikke den store designhaj, men pointen er også klart at lave en teknisk velfungerende løsning, så det er heller ikke mange minutter der er spildt på design.

Lang.NET

En af de nyheder jeg senest er faldet over ved at abonnere på blogs rundt omkring er, at der for nylig blev afholdt Lang.NET symposium (http://langnetsymposium.com/talks.asp), hvorfra der er udgivet en række interessante webcasts. En af de casts jeg især synes var interessant var Eric Meijer der talte om Volta. Jeg synes det er et virkeligt interessant eksperiment, og håber da meget det kan udvikle sig til et alternativ til den måde man udvikler applikationer på idag. Kort fortalt går Volta ud på at man koder en applikation som single tier, og vilta frameworket kan så ved hjælp af MSIL rewriting splitte applikationen i flere lag, lave asynchronous kald og sørge for at oversætte koden så den kan afvikles i det miljøet tilbyder i et givent scenarie. Noget der især virker som sort magi på mig er tanken om at frameworket kan omdanne kode i et CLR sprog til javascript - dette har naturligvis sine begrænsninger men er alligevel ganske fascinerende.

Udover Volta var der også andre interessante taler af blandt andet danske Anders Hejlsberg, der talte om C# 3.0 og kort kommer ind på nogen af de ting de har på tegnebrættet til version 4.0 eller hvad den nu kommer til at hedde. Også F# som jeg har rodet lidt med i fritiden her på det sidste var der et par taler omkring - hvor den ene dog mest omhandlede parsere og leksere, som er en af de ting F# tilbyder nogle specielle features til at understøtte.

Tags: , ,

F# funktionelle typer og objekt-orienteret programmering

by DotNetNerd 27. January 2008 17:51

F# funktionelt eller objektorienteret?

En stor del af dem der har hørt om F# har hørt at det er et funktionelt programmeringssprog, hvilket er sandt nok - det er bare ikke udelukkende funktionelt. Faktisk understøtter sproget i lige så høj grad at man kan programmere objekt orienteret med imperative teknikker. Det er faktisk netop derfor F# er brugbart i ”den virkelige verden” i modsætning til eksempelvis Haskell der stort set udelukkende benyttes til undervisning i praksis.
Jeg vil i dag kigge på forskellige teknikker til at arbejde med typer, først med udgangspunkt i funktionel programmering og sidenhen med fokus på objektorientering.

Simple typer til funktionel programmering

I funktionel programmering arbejder man meget med objekter på to måder, nemlig med records og discriminated unions. Records svarer til det man ellers kalder en entitet, som er et helt simpelt databærende objekt.

type Employee =
  { Name: string;
    HiredDate: System.DateTime; }

Som så kan bruges således, hvor type udledes via ducktyping - if it walks like a duck and it talks like a duck, its probably a duck.

let employee1 =
  { Name = "Christian";
    HiredDate = System.DateTime.Parse("11/07/2003") }

Eller således.

let employee2 =
  { new Employee
    with Name = "Hans"
    and HiredDate = System.DateTime.Parse("11/07/2003") }

En smart feature der skal nævnes I den forbindelse er at det er nemt at klone records, så hvis man skal lave en ny record der næsten er magen til en anden kan man eksempelvis gøre det sådan her.

let employee1Cloned = { employee1 with HiredDate = System.DateTime.Parse("15/10/2005") }

Discriminated Unions bruges til at modellere et endegyldigt og lukket sæt af muligheder der ikke kan ændres. Man arbejder typisk med med discriminated unions ved først at definere nogle type forkortelser, som ganske enkelt består i at man giver en eksisterende type et alias.

type Route = int
type Make = string
type Model = string

Derefter kan man så bygge sit discriminated union ved hjælp af forkortelserne sådan her.

type transport =
  | Car of Make * Model
  | Bicycle
  | Bus of Route

Som man forhåbentlig kan se ud af det her er det en meget præcis måde at modellere del slags data på. Ud fra ovenstående kan man nu arbejde med typerne sådan her.

let myMeansOfTransportation = [ Car("Skoda", "Fabia"); Bicycle; Bus 128 ]

Det har muligvis allerede slået dig at den her måde at modellere på minder om ”enumerations på speed”, og rent faktisk opbygges enums i F# sådan her.

[<Struct>]
type Shape =
  | Circle = 1
  | Rectangle = 2
 

Objektorienteret programmering

Den vigtigste egenskab ved objekter er at de indkapsler mutable værdier, og bruges dermed til at indkapsle tilstand - således at omdrejningspunktet for koden er tilstands checks og tilstands ændringer.
Som jeg skrev i sidste post er værdier som udgangspunkt immutable i F#, hvilket er en stor styrke idet man derved ligger op til at tænke i at skrive kode der ikke afhænger af tilstandsstyring hvilket hurtigt kan blive rodet og svært at vedligeholde. Det kan imidlertid være nødvendigt med mutable værdier, og i nogen tilfælde er det med til omvendt at gøre kode lettere at læse og mere effektivt.
Helt enkelt gøres en værdi mutabel ved hjælp af nøgleordet ”mutable” og den kan derefter modificeres ved hjælp af operatoren <- på samme måde som man kender der fra VB og C# med = tegnet.

let mutable n = 0
n <- 6
printfn "%d" n

En anden velkendt teknik er at anvende mutable reference celler ved hjælp af nøgleordet ref og operatorerne := til at sætte en værdi og ! til at hente den, som du kan se brugt her.

let n = ref 6
n := 7
printfn “%d” !n

Andre uundværlige teknikker fra objektorienteret programmering er boxing/unboxing af værdityper og upcasting/downcasting imellem typer. Boxing af en type vil sige at wrappe dem til objekter, således at de kan gives til metoder der tager typen object.

let o = box 6
let i = unbox<int> o  // kan også skrives som let i = unbox o : int

Upcasting bruges til at caste en type til en type den arver fra.

let stringObject = ("qwerty" :> obj)

Downcasting bruges til at caste en variable til en mere nedarvettype som den er en instans af.

let myString = stringObject  :?> string
 

Members - objektets ansigt udadtil

Som tidligere nævnt er indkapsling en nøgleegenskab i objektorienteret programmering. Ligesom i andre .NET sprog  kan værdier pyntes med modifieren private hvis de ikke skal være tilgængelige udefra. Derudover kan man naturligvis lave members der stilles til rådighed for andre som vi nu skal se nærmere på.
Mutable properties er nok den mest anvendte membertype, idet de helt enkelt bruges til at stille data til rådighed. En property ser sådan her ud i F#.

let mutable text = ""
member t.Text
  with get() =
    text
  and set v =
    text <- v

Indexers bruges på samme måde, men bruges til at tilgå data som en collection af data der tilgås via en eller flere indeks parametre.

let elems = [| "A"; "B" |]
member t.Item
  with get(id) = elems.[id]
 

Argumenter der holder

I F# kan man benytte sig af teknikker som optionelle- og navngivne argumenter. Optionelle argumenter angives ved hjælp af ? hvilket gør at værdien bliver en option og den kan altså dermed være ingenting.
defaultArg funktionen bruges til at trække værdien ud eller alternative en default værdi hvis optionen er None.

type LabelInfo(?text:string) =
  let text = defaultArg text ""

Named arguments er en anden teknik der relaterer sig til at arbejde med argumenter. Ved at bruge named arguments angiver man værdien for et argument præcist frem for ud fra argumentets placering. En smart feature i den forbindelse er at man kan angive argumenter som der ikke nødvendigvis er en constructor til så længe typen har en public property til den angivne parameter.

let form = new Form(Visible=true, TopMost=true)
 

Implementation af interfaces

Nu er det vidst ved at være tid til at se på hvordan man implementerer en klasse som vi kender den fra VB eller C#. For at starte fra bunden ses her hvordan man deklarerer et interface.

type IShape =
  abstract Contains : Point -> bool

Ovenstående interface kan derefter implementers af en funktion på følgende måde.

let Circle() =
  { new IShape with
    member x.Contains(p:Point) = true
  }

Teknikken der er anvendt her kaldes object expressions og det er en simpel teknik der anvendes ofte når man implementerer interfaces eller extender typer.
Definitionen af en object expression er sådan her.

{ new Type optionalle-argumenter with
            Member-definitioner
  Optionalle-ekstra-interface-definitioner }

En implementation af et interface på en konkret type som man nok oftere vil bruge den kan se sådan her ud.

type MutableCircle() =
  let mutable center = Point(x=0, y=0)
  member c.Center with get() = center and set(v) = center <- v
  interface IShape with
    member c.Contains(p:Point) = true
 

Brug af delvist konstruerede typer

Delvist konstruerede typer er typer der har abstrakte members, som skal implementeres af en specialiseret type. Alternativt kan man angive en default implementation som kan overskrives af den type der nedarver.

type Formatter() =
  abstract Format : string -> string
  abstract ReplaceWhitespace : string -> string
  default x.ReplaceWhitespace(s:string) = s.Replace(" ", s)

En sådan klasse kan implementers ved hjælp af object expressions.

let myFormatter =
  { new Formatter() with
    member f.Format(s) = s }

Eller den kan ligeledes implementeres via implementation inheritence.

type HtmlFormatter() =
  inherit Formatter()
  default f.Format(s) = s

I forbindelse med implementation af en given member kan nøgleordene override og default bruges til at indikere om man overskriver en metode der har en implementation i forvejen eller ej.

Statiske metoder og extension methods

Statiske metoder i F# implementeres ikke på en klassen, men på et module. Ønsker man at en statisk metode skal ligge på en klasse (eller dele navn med den om man vil) skal modulet dekoreres med en CompilationRepresentation attribute.

[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module MyOperations =
  let MyStaticMethod(i:int, i2:int) = "Taller er " + (i + i2).ToString()

En relateret teknik er deklerationen af extension methods som også for nylig er kommet med i VB og C#.
En extension method i F# deklareres som en del af modulet med følgende syntaks.

type System.Int32 with
    member i.Add(i2:int) = MyStaticMethod(i, i2)

For at bruge extension metoden skal man derefter blot åbne modulet, på samme måde som i VB.

open MyOperations

let i = 1
let s = i.Add(12)
 

Afrunding - muligheder for fremtiden

Jeg håber at have illustreret med ovenstående gennemgang at man kan bruge F# til at arbejde fuldt ud objekt-orienteret, på holde med det man kan i andre .NET sprog. Netop det at man kan mix and matche imellem paradigmer er efte rmin mening den helt store styrke ved F#. Jeg er selv kun ved at komme igang med sproget og kaster mig i næste uge ud i at lave mit første modul i sproget, som bliver et stregkodeparser til mig FLOwer Tracker system. Jeg håber det har givet andre lyst til at prøve kræfter med sproget som jeg nok ender med at skrive meget mere om med tiden efterhånden som det vinder frem og bliver kørt ind i .NET frameworket fuldt ud som planen er fra Microsofts side.

 

Tags:

F# igang med funktionel programmering

by DotNetNerd 29. December 2007 18:46

F# - brugbar funktionel programmering

For en god uges tid siden dumpede bogen "Expert F#" endelig ind af min brævsprække - noget jeg har glædet mig til i et stykke tid, da jeg har hørt mange spændende ting om sproget. Inspireret af at jeg engang læste at man bør lærer sig et nyt programmeringssprog hvert år synes jeg det var det perfekte næste skridt for mig. Jeg har absolut ingen erfaring med funktionel programmering udover det jeg har rodet med LINQ - hvilket ikke er helt "rigtig" funktionel programmering men rettere funktionel funktionalitet indarbejdet i et Objekt Orienteret sprog.

Idet jeg næppe er den eneste der ikke har rodet med funktionel programmering, da det hovedsageligt har hørt hjemme på universiteterne hidtil, vil jeg skrive en smugle om nogen af de basale ting i funktionel programmering og F#. Hvis du tænker "hvis det hvedsageligt hører hjemme på uni, hvad kan jeg så bruge det til i praksis", så er pointen netop at F# udover at være et funktionelt sprog, også giver mulighed for at tilgå .NET frameworkets mange herligheder, og arbejde imperativt hvis man vil. Jeg tror F# har gode muligheder for at vinde frem netop
af den årsag, da det tilbyder fantastisk ekspressivitet sammen med adgang til de ting vi bruger .NET frameworket til allerede.

Lidt basics

Lidt ligesom der i VB findes option strict og explicit er der i F# "#light", som aktiverer det der kaldes light syntaks. Med andre ord slipper man for at skrive en masse ting og afslute linier manuelt osv. Eller kort sagt, bare skriv det øverst i din kode!

Kommentarer i F# minder langt hen ad vejen om den måde man skriver dem på i C#, med undtagelse af flerlinies kommentarer.

// Her er en enlinies kommentar.

(* Her står der en
flerlinies kommentar *)

///<summary>Xml kommentarer ligner også sig selv som i C#</summary>

Lidt ligesom man har Dim, var o. lign. ord der deklarerer en variabel har man i F# ordet "let" der definerer starten på en funktion. For at illustrere og vise hvordan scope fungerer er her et eksempel:

let powerOfTwo number
  let result = number * number
  result

Her definerer man en funktion der hedder powerOfTwo, som tager et argument "number". Funktionen består af en lokal funktion der er tallet ganget med sig selv. Man kan også se at inferens af typer bruges i meget vid udstrækning og at indrykning bruges til at afgrænse scope ligesom i (Iron)Python.

For at undgå at skulle ud i den helt langt gennemgang af simple typer og operatorer vil jeg nøjes med som udgangspunkt at sige at de langt hen ad vejen er de samme som i C# og ellers er der masser af steder man kan finde oversigter over dem via vores allesammens bedste ven google.

Det er vigtigt at vide at operatorer er unchecked. Operationer der giver overflow kaster altså ikke exceptions men de wrappes istedet. En anden ting der er vigtig at forstå er at de fleste typer er immutable med mindre det explicit angives at de skal være mutable. Det giver en række fordele, da man derved kan være sikker på at en værdi ikke ændres "bag om rykken" på en. Noget der især er rart når man arbejder trådet da man så ikke skal bekymre sig så meget om "concurrent access".

Grundlæggende data strukturer

Fleksible datastrukturer er en af hovedingredienserne i et funktionelt sprog, da de gør det muligt at skrive meget ekspressiv kode til at arbejde med mængder af data.

Tuple:

Tupler bruges til at returnerer flere værdier fra en funktion, som ikke nødvendigvis er af samme type. En tupel angives helt enkelt med en parentes hvori værdierne adskilles af en komma. En funktion der tæller ord kunne for eksempel returnere, totalt antal ord og antallet af unikke ord.

let wordCount = (10, 8)

fst og snd er keywords der bruges til at anvende det første og andet element i en touple - og dermed til at arbejde med par.

let totalWordCount = fst wordCount

En anden mulighed er at decompose tuplen i flere værdier.

let totalWordCount, totalUniqueWordCount = wordCount

Array:

Arrays kender de fleste nok ganske godt så dem vil jeg gå lidt let hen over. En vigtig ting at nævne er dog at arrays er den eneste af de collection strukturer jeg skriver om her der er mutable. Et array i F# defineres således:

let myArray = [|1;2;3;4;5|]

En anden funktion der er værd at nævne er at man kan definere et litteral byte array som:
let myArray = "MAGIC"B // Det svarer til [|77uy; 65uy; 71uy; 73uy, 67uy|]

Array slicing som ellers er en ting man godt kan savne lidt i andre .NET sprog kan desuden laves således.

let slicedArray = myArray.[1 .. 3]

List:

List i F# er en implementation af en singularly linked list som er en struktur der læses hurtigt hvis man læser elementerne igennem fra
start til slut.
 
let oneHalfOfTheFamily = ["Claus";"Lena";"AC"]
let anotherHalfOfTheFamily = ["Allan";"Janni";"Peter";"Jacob"]
let bothHalvesOfTheFamily = oneHalfOfTheFamily @ anotherHalfOfTheFamily

Her set man to lister blive oprettet og smeltet sammen. Det er vigtigt at huske at lister er immutable, så efter dette er sket er værdierne af de to første lister uændrede.

Set:

Sets indeholder ordnede lister hvor der kun kan være 1 af hver værdi, og sets er case sensitive. Et eksempel illustrerer meget godt hvordan den bruges.

let myset = Set.of_list ["BAC";"ABC";"ABC"]

Vil give en Set<string> med indholdet ["ABC";"BAC"]

Sets kan laves til lister eller laves fra lister ved hjælp af to_list og of_list

Option:

Options bruges til at beskrive en struktur der enten har en værdi eller er None. Keywordet her er "Some" og kan bruges således.

let childAndParents = [ ("Jens", Some("Ib", "Hanne"));"Jonas", None]

Options har funktioner som get der returnerer værdien af en some option og is_option der returnerer true for en some option.

Sequence:

Sequences er en abstraktion over datastrukturer der kan læses sekventielt og er alt der implementerer IEnumerable, som man kender det fra andre .NET sprog. I F# har sekvenser deres eget keyword som er seq. Det vil sige alle typer der er IEnumerable kan arbejdes med som sekvenser, det inkluderer arrays, lists osv. En smart F# feature er at man kan beskrive ranges af værdier i sekvenser på følgende måde.

let myNumbers = seq {0 .. 5}

Som vil give en sequence af værdier fra 0 til 5. Denne liste er lazy således at værdierne ikke genereres før de skal bruges. Dette er meget vigtigt hvis man skal arbejde med rigtigt lange sekvenser. Man kan desuden definere et interval i sevensen således.

let myNumbers = seq {1 .. 2 .. 6}

Som vil give værdierne [1;3;5]

Eller man kan definere en sequence ud fra f.eks. et for expression:

let powersOfTwo = seq { for i in 0 .. 10 -> i*i }

List og Seq indeholder desuden en række funktioner som eksempelvis map, iter, filter, to_array og of_array. De først nævnte gør det nemt at arbejde med strukturerne ved at passe en funktion ind.

powersOfTwo.iter(fun number -> Printf.printf "Number = %s\n" (number)

Functionelle værdier

En anden vigtig bestantdel i et funktionelt sprog er naturligvis muligheden for at arbejde med funktionerne. En række metoder som for eksempel map og iterate der findes på blandt andet List og Sequence tager imod en funktion som argument. Map bruges til at omforme alle elementer i strukturen og iterate bruges til at iterere strukturen og udføre funktionen på hvert element. En funktion kan som shorthand skrives som:

let namesWithH = Names.Filter(fun name -> name.StartsWith("J"))

Man har desuden mulighed for at "pipe" funktioner, sådan at en funktion kaldes med retur værdien fra den forrige funktion. Piping er en god
måde at gøre kode mere let læseligt på da det kan læses fra højre mod venstre og ikke indefra ud som man ellers tit ender med at skulle.


let PrintNamesWith prefix =
  NamesWith(prefix) |> List.iter(fun name -> Printf.printf "Name = %s\n" (name))


Man kan også arbejde med sammensatte funktioner og partiel applikation. Disse to teknikker viser hvor fleksibelt sproget er når man arbejder med funktioner.

let getNames s = String.split [';'] s
let countNames = getNames >> List.filter(fun (name:string) -> name.StartsWith("M")) >> List.length
let NameCount = countNames "Mia;Christian;Mig"

Eksmeplet viser hvordan man givet en funktion "getNames", kan definere en ny funktion countNames, som er en sammensætning af denne, List.filter og List.length - som derved kan bruges til at tælle antallet af navne i en semikolon separeret streng. F# har en meget powefull engine til at sammensætte effektive funktioner på denne måde.


let shift (x, y) (x1, y1) = (x1+x, y1+y)
shiftright = shift(1,0)

Dette eksempel viser helt enkelt at man kan definere en ny funktion ved at kalde en anden funktion med kun nogen af de argumenter den kræver. Dette giver mulighed for at være meget beskrivende i sin kode ved at lave en række partielle funktioner der løser specifikke opgaver på baggrund af en mere generel funktion.

Konklusion

Jeg håber ovenstående givet et godt indblik i nogle af de mest basale strukturer og teknikker der anvendes i F# i forbindelse med funktionel programmering. Som tidligere nævnt er F# ikke et "rent" funktionelt sprog så man kan også arbejde med imperativ programmering i sproget. Det kan være det bliver et emne jeg tager op senere. Selvom jeg er ny indenfor funktionel programmering synes jeg hurtigt man får et indtryk af hvor ekspressiv kode man kan skrive og at det er vejen frem især hvis man skal kode en applikation til et trådet miljø.

Tags:

Opsætning af IIS 7.0 og Windows Communication Foundation i Vista

by DotNetNerd 16. December 2007 14:50

Jeg opdagede idag at det er knap så "lige ud af boksen" som man kunne ønske sig at afvikle ASP.NET og Windows Communication Foundation services under Vista og IIS 7. Man kan kun undre sig over at ihvertfald ASP.NET ikke automatisk installeres ved installation af IIS, men det er åbenbart ikke tilfælder. Det lykkedes dog efter at have rodet lidt at få det til at virke og jeg vil derfor lige skrive en guide hvis andre skulle støde på samme problem. 

Installation af IIS og ASP.NET på Windows Vista

For at kunne afvikle en ASP.NET applikation skal man først installere IIS og den tilhørende ASP.NET komponent. Dette kræver administrator rettigheder og gøres ellers ved at:

  • Gå til kontrolpanel -> Programmer og funktioner.
  • Herfra vælger du "Slå windows funktioner til eller fra" i sidemenuen til venstre i vinduet.
  • Vælg internet Information Service og udvid punktet.
  • Udvid "værktøjer til webmanagement" og "kompatibilitet med IIS 6 management".
  • Vælg "Kompatibilitet med IIS-metabase og IIS 6-konfiguration".
  • Udvid også "World wide web services" og Funktioner til programudvikling.
  • Vælg ASP.NET checkboksen.

Du kan nu afvikle ASP.NET applikationer ved at oprette dem på almindeligvis via IIS management værktøjet - eller bruge default sitet ved at smide det i inetpub/wwwroot.

Installation af WCF service modellen

For at kunne afvikle en Windows Communication Foundation service skal service modellen registreres.

Dette gøres ved at:

  • Åben en kommandoprompt med admin rettigheder.
  • Gå til %Windows%\Microsoft.Net\Framework\v3.0\Windows Communication Foundation\
  • Check status ved at skrive ServiceModelReg -vi og se om service modellen allerede er installeret.
  • Er den ikke installeret skriv ServiceModelReg -i og så skulle modellen blive installeret.

Og nu kan du så også afvikle en Windows Communication Service.

Lige for en god ordens skyld skal det siges at for at hoste en WCF service under IIS 7 skal man blot smide en svc fil med følgende indhold i roden af sitet.

<%@ ServiceHost Language="C#" Debug="true" Service="Syndication.FeedService" %>

Hvor servicen skal pege på klassen der implementerer din service. Dll'en skal ellers bare ligge i en bin mappe som den plejer.

Tags: , ,

Silverlight del 3 - ready, set, draw

by DotNetNerd 2. December 2007 16:56

I sidste blogindlæg om silverlight nåede jeg lige kort at berøre Path elementet, som har en Path.Data collection bestående af Geometry elementer som tegnes.

Der findes 4 basale typer geometry elementer som er:

  • RectangleGeometry
  • EllipseGeometry
  • LineGeometry
  • PathGeometry

De 3 første fungerer på samme måde som de tilsvarende elemeter jeg gennemgik i sidste blogindlæg, og RectangleGeometry blev ligeledes berørt i eksemplet på at bruge Path.

PathGeometry

PathGeometry er et meget komplekst element der kan bestå af en række segmenter, som findes i 7 forskellige typer:

  • LineSegment
  • PolyLineSegment
  • ArcSegment
  • BezierSegment
  • PolyBezierSegment
  • QuadraticBezierSegment
  • PolyQuadraticBezierSegment

Disse elementer kan tilføjes til et PathFigure element - som der så igen kan være flere af i et PathGeometry element.
PathFigure har en StartPoint property som beskriver hvor der tegnes fra og derefter tegnes de tilføjede segmenter efter hinanden. Som altid siger et eksempel mere end 1000 ord. 


<Canvas Name="Canvas1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="640" Height="480">
 <Path Name="Car" Stroke="Green" Canvas.Left="100" Canvas.Top="100" StrokeThickness="1">
  <Path.Data>
   <PathGeometry>
    <PathFigure StartPoint="50,50">
     <LineSegment Point="100,100" />
     <ArcSegment Point="150,150" Size="20,20" />
     <BezierSegment Point1="250,300" Point2="200,50" Point3="0,0" />
     <ArcSegment Point="50,50" Size="20,20" />
    </PathFigure>
   </PathGeometry>
  </Path.Data>
 </Path>
</Canvas>

Som det fremgår kan man tegne virkeligt komplekse ting med meget enkle midler. 

Geometri elementer som strenge

En smart feature er at Geometries kan beskrives som strenge, hvilket tillader en væsentligt mere kompakt syntaks. Læsevenligheden kan man tilgengæld godt stille spørgsmålstegn ved, men det kan være det bliver lettere når man bliver lidt mere rutineret.

Jeg vil undgå at gennemgå alle kommandoer, da der alligevel allerede findes omfattende sites hvor man kan slå den slags ting op, men vil da give et eksempel på nogen af de mest brugte ved at tegne den ovenstående figur igen ved hjælp af en kommandostreng.

M angiver StartPoint og er derved altid angivet. Ved at slutte med Z kan man iøvrigt sørge for at figuren lukkes - dette svarer til at sætte propertien IsClosed="True" på PathFigure.
L angiver at der skal tegnes en linie hen til et punkt.
A angiver at der skal tegnes en arc ud fra formlen "A radiusX radiusY grader IsLargeArc Clockwise x,y".
C angiver at der skal tegnes et beziersegment ud fra formlen "C punkt1X,punkt1Y punkt2X,punkt2Y x,y".

Alle kommandoer kan desuden skrives som lowercase hvilket bevirker at de fortolkes relativt til nuværende punkt frem for som absolute koordinater.

For at tegne den figur vi havde tidligere kan vi derfor gøre følgende.

<Path Name="Car" Stroke="Green" Canvas.Left="100" Canvas.Top="100"
 Data="M 50,50 L 100,100 A 20,20 0 0 0 150,150 C 250,300 200,50 0,0 A 20,20 0 0 0 50,50" StrokeThickness="1" />

Dette virker nok knap så intuitivt at læse, men da man nok oftest vil arbejde med et værktøj som expression blend er det smart at have en kompakt syntaks, da man derved også begrænser hvor meget ens XAML skal fylde.

Clipping ved hjælp af Geometries

Geometries kan ikke kun bruges til at tegne elementer, men også til at beskære andre elementer.  Dette gøres ved at sætte et hvilket som helst elements Clip element til et Geometry element. For eksempel kan en Ellipse beskæres af en anden ellipse således.

<Ellipse Width="250" Height="150" Fill="Orange" Stroke="Black" StrokeThickness="3">
  <Ellipse.Clip>
   <EllipseGeometry RadiusX="150" RadiusY="200" />
  </Ellipse.Clip>
 </Ellipse>

Dette giver især spændende muligheder hvis man f.eks arbejder med billeder eller video, hvor det også er muligt at benytte denne teknik. Derved kan man lade en film afspille i hvilken som helst form man kan tænke sig, eller man kan lade alle billeder på ens side blive beskåret ens så der er endnu en måde at lave et custom design på.

Tags:

Silverlight del 2 - back to the drawingboard.

by DotNetNerd 24. November 2007 10:25

Basal viden om grafiske elementer i Silverlight 

I Silverlight del 1 snuste jeg en lille smugle til det at lave en brugerflade i XAML, og kom igennem det mest basale med at man skal have et canvas som rod element og jeg viste hvordan man kan indsætte en TextBlock. Nu vil jeg så gå videre og se på en række andre elementer man kan bruge til at tegne brugergrænseflader med.

Faktisk kan man bruge TextBlocken fra sidst som udgangspunkt, da den viser nogle af de grundlæggende properties som findes på alle grafiske elementer: Name, Canvas.Left og Canvas.Top. Disse properties vil man sandsynligvis sætte på et hvert element sådan at det har et navn man kan bruge til at finde elementet programmatisk, og sådan at man kan styre hvor elementer placeres. Hvis man skal finde et element ud fra dets navn er der en funktion som kan kaldes fra alle grafiske elementer der hedder FindName("kontrolnavn") f.eks. kan man finde en kontrol med navnet mySquare således.

var myControl = rootElement.FindName("mySquare");

Basale former 

Der findes 3 helt basale former man kan tegne i silverlight som er:

  • Rectangle
  • Ellipse
  • Polygon

Rectangle 

Rectangle er en af de mest brugte former, da den giver en meget enkel måde at tegne rektangler på. Det er faktisk så enkelt at jeg vil lade et eksempel tale for sig selv.

<Rectangle Width="200" Height="100" Fill="Green" Stroke="Black" StrokeThickness="5" />

Hvad der gør ekementet endnu smartere er at det har to Properties der hedder RadiusX og RadiusY, som kan bruges til at lave runde hjørner. RadiusX kan antage en værdi fra 0 og op til halvdelen af elementets Width - og tilsvarende kan RadiusY være op til halvdelen af Height.

Ellipse

Selvom man faktisk med hjælp af RadiusX og RadiusY som beskrevet kan lave et Rectangle til en ellipse findes der også et element beregnet til formålet hvis man ønsker at regne ellipser.

<Ellipse Width="200" Height="100" Fill="Green" Stroke="Black" StrokeThickness="5" />

Her beskriver Width og Height det areal som ellipsen vil fylde ud, hvilket gør det enormt nemt at arbejde med. Man kan ved at sætte propertien Stretch til enten "None", "Uniform" eller "UniformToFill" ændre på måden ellipsen skaleres på. None gør at ellipsen ikke fylder noget, og det vil derfor kun være Stroke (altså elementets kant) man kan se. Uniform og UniformToFill sørger for at elementet altid er lige så højt som det er bredt. Forskellen består i at Uniform vælger den mindste værdi sådan at ellipsen kan være inden for arealet man definerer hvor UniformToFill vælger den største så kan fylder arealet ud og den overskydende del af ellipsen skæres væk.

Polygon

Den sidste basale form er polygon eller "mangekant som det hedder på dansk". For at definere en sådan form angiver man en række points som er koordinatsæt (x,y) der beskriver skæringspunkterne.

<Polygon Fill="Green" Stroke="Black" StrokeThickness="5" Points="10,10 100,100 200,5" />

Idet en polygon kan være meget kompleks og have flere krydsende punkter kan det være svært at afgøre hvilke områder der er indenfor og ydenfor formen, og der med hvilke der skal fyldes af Fill farven. Til at styre dette har polygoner en property FillRule som kan sættes til "EvenOdd" eller "NonZero". EvenOdd er default og fylder kun regioner hvis man vil krydse et ulige antal segmenter for at gå fra området til et område uden for polygonen. NonZero er en mere kompleks algoritme som oftest vil betyde at alle arealer indenfor polygonen fyldes.

Linier

En anden mulighed for at lave grafiske elementer er at tegne linier. Også her findes der 3 elementer som vi kan benytte os af.

  • Line
  • Polyline
  • Path

Line

Line elementet bruges til at tegne en helt enkel streg fra punkt 1 til punkt 2. 

<Line X1="10" Y1="10" X2="100" Y2="100" Stroke="Black" StrokeThickness="5" />

Polyline

Polyline er som du måske har gættet til at tegne flere linier efter hinanden. Dette gøres ligesom for polygoner ved at definere et antal Points.

<Polyline Points="10,10 100,100 200,5" Stroke="Black" StrokeThickness="5" />

Hvis man sætter Fill propertien på en polyline der ikke udgør en lukket figur vil arealet det bliver fyldt svare til hvis man trækker en linie fra det første til det sidste punkt.

Path

Path er en mere kompleks struktur der kan udtrykke hvilken som helst form. Dette gøres ved at sætte dennes Data element der kan sættes til et vilkårligt geometry element. Da geometry elementer er et helt emne i sig selv vil jeg nøjes med at vise et eksempel der viser hvordan man laver et rektangel.

<Path Fill="Blue">
 <Path.Data>
  <RectangleGeometry Rect="0,0 80,80" />
 </Path.Data>
</Path>

Ligesom diskuteret tidligere har RectangleGeometry også RadiusX og RadiusY properties til at lave afrundede hjørner.

Tags:

Who am I?

My name is Christian Holm Diget, and I work as an independent consultant, in Denmark, where I write code, give advice on architecture and help with training. On the side I get to do a bit of speaking and help with miscellaneous community events.

Some of my primary focus areas are code quality, programming languages and using new technologies to provide value.

Microsoft Certified Professional Developer

Microsoft Most Valuable Professional

Month List

bedava tv izle