Microsoft track at GOTO

by dotnetnerd 14. August 2014 11:00

8486791170_005e569bec_b Its a good thing I wrote my last blogpost when I did – otherwise I would not have had the chance to complain about the missing Microsoft track :) Shortly after I published my post, the conference announced just that track, and that Mads Kristensen is doing one of the talks on web tooling for ASP.NET. As a web-guy, that is really nice to hear, because Mads tends to have a bunch of good ideas to share, and he always gives a good talk.

More...

SQL and NoSQL tools as you know and love them with F#

by DotNetNerd 6. May 2013 14:31

toolsWhile looking at how you can do your common scenarios in F# an obvious thing to look at is data access. I already covered type providers which are fantastic for consuming data. However type providers won't help you when you need to create data or in other ways interact with your SQL database, MongoDB, RavenDB or any other NoSQL solution you might be using. For this you will most likely want to use some of the libraries you already know and love - there is no reason to reinvent everything.

Working with existing libraries is mostly trivial, but F# likes types that are immutable which straight out of the box doesn't play well with serialization and mapping. This means that ORM's and libraries for MongoDB and RavenDB will throw exceptions when they try to construct your F# types. This basically boils down to the fact that code like the sample below won’t work, because the serializer can not instantiate the type and fill in the values.

More...

Canopy – web testing in 10 lines of code

by DotNetNerd 16. April 2013 13:22

With my latest dive into F# I recently came across Canopy, which is a really nice and simple web testing framework. It really is as simple as installing a package and writing a few lines in a console application.

More...

Type Providers – all you can eat data buffet

by DotNetNerd 28. March 2013 20:08

BuffetI shortly wrote about Type Providers for SQL databases and services in a blog post last year, and since then a range of new providers have been written by the community. Just a quick search and you can find providers for WMI, CSV, XML, Regular expressions, REST services, world bank and pretty much every other thing you can imagine. Especially FSharpX and some of the excellent work done by people like Tomas Petricek.

After looking around I was surprised to see some of the use-cases. I was thinking in the lines of what LINQ provides until I saw samples like the provider for regular expressions.

More...

Indulging in my love for programming languages

by DotNetNerd 3. February 2013 20:12

books-300x272I have started this year spending some spare time with two of my favourite languages, besides C# that I primarily use to earn a living. The two languages in question are F# and Python. The represent two other paradigms from the statically typed and object oriented ones that are by far the most main stream, with languages like Java, VB and all the C-family languages. Playing with other paradigms is a great way to learn how some problems may be solved more elegantly either by going polyglot or simply by implementing some of the basic ideas of another paradigm in the language that you work with on a daily basis.

More...

F# Type Providers and WebAPI

by dotnetnerd 4. April 2012 10:35

imagesLater this month on the 25th I will be speaking along with two other speakers about webframeworks at an ANUG meeting. The frameworks covered are ServiceStack, Nancy and WebAPI where I will cover the latter.

While I have been preparing my eye cought a new feature in F#, which I think is one of the first really good stories for F# that makes sence outside akademia and science. Type Providers give us a way to access data sources that provide its own metadata, and this fits nicely with building WebAPI services.

More...

Nye funktionelle tiltag i C# 4.0

by DotNetNerd 16. November 2008 09:23

Udover at inkludere features fra dynamiske sprog som er et af hovedområderne Microsoft arbejder med til C# 4.0 kommer der også nogle flere features inspireret af F# og funktionel programmering. Tupler og en Zip funktion til Enumerable klassen kan man læse om på codebetter idag.

Især tupler har jeg savnet indimellem, så jeg er spændt på at se hvordan de lykkedes med at integrere dem i C# med hensyn til dekomposition, da det er det sprængende punkt for hvor anvendelige de bliver. Zip funktionen ser også ud til at blive en ok tilføjelse, men de fleste opgaver den løser kan man trodsalt løst rimeligt simpelt i forvejen, og om ikke andet ville det være simpelt nok at skrive den selv som extention method. 

Alt i alt er det imidlertid rart at læse at de samarbejder med F# teamet for at gøre sprogene mere kompatible, og derved gøre det lettere at skrive moduler i de to sprog der kan bruges sammen. Idag er det en rimelig stor hemsko at man skal gøre en indsats for at ens API fra et F# modul kun anvender typer der er tilgængelige i andre sprog hvis modulerne skal bruges sammen.

Tags: ,

ANUG snak og de korte nyheder

by DotNetNerd 25. September 2008 18:10

Snak for ANUG om F#

Igår var det så langt om længe dagen hvor jeg skulle til Århus for at snakke om F# for Århus .NET usergroup. Jeg har set frem til den udfordring det er i et stykke tid, og heldigvis gik snakken rigtigt godt, og jeg blev meget positivt modtaget i smilets by. Det er fedt at se at der er så mange andre der har interesse i at lære om et sprog som F#, og at stemningen var helt i top med et fagligt højt niveau og plads til at grine lidt af tingene. Jeg gik selv derfra med en rigtig god oplevelse i bagagen, og en hel del erfaringer rigere, da det var en super fed udfordring at tale om et meget nørdet emne for en relativt stor forsamling. Alle deltagende skal ihvertfald have tak for en fed aften herfra :-)

AntiXssLibrary

I den seneste udgave af MSDN magazine faldt jeg over en artikel der hedder "SDL Embraces The Web" som jeg synes var ganske interessant. SDL står for "Security Development Lifecycle" som er et team der arbejder med af lave værktøjer til og beskrive sikring af applikationer imod angreb. Artiklen omhandler helt basale princippet for hvordan man kan sikre sine applikationer ved hjælp af validering, encoding, permission restriction og Parameterized SPROCS.

So far so good. Ikke meget nyt under solen, men det er altid sundt lige at få genopfrisket de her ting - og til det formål er artiklen ganske velskrevet og med nogen gode eksempler. Det der gjorde artiklen mere interessant for mig er hvor de nævner AntiXssLibrary som man kan bruge til at sikre imod XSS (cross-site scripting) ved at encode sit output. Der nævnes syv forskellige scenarier der kræver at man bruger en forskellig type encoding (HTML, HTML attribute,  URL, Javascript, VBScript, XML og XML attribute) og at Microsoft Application Consulting and Engineering teamet derfor har lavet det her library. AntiXssLibrary består af en hovedklasse der hedder AntiXss, som indeholder en stribe statiske metoder til at håndtere de her forskellige typer encoding let og smertefrit. Min personlige erfaring er at det er de færreste udviklere der er gode til at huske at encode deres output - selvom jeg kender nogen der gør det indimellem er det sjældent helt konsekvent. Netop af den årsag synes jeg det her library er interessant fordi det gør encoding så let at der ikke er nogen undskyldning for ikke at bruge det.

DateTime.Utc

For nylig fik jeg til opgave at skrive en applikation der skal bruges fra Danmark, Hong Kong og Kina og som skal kunne vise dato og tid korrekt. Det lød jo ikke som nogen større udfordring, for hvor svært kunne det være at korrigere for nogen tidszoner med plus minus nogen timer. Det viste sig imidlertid at det faktisk ikke er så nemt endda, hvis applikationen skulle laves så der også kunne komme andre lande til. I virkeligheden er det åbenbart ikke kun hele timer der kan være i forskel, og der er stor forskel på om lande bruger sommer/vintertid og i givet fald hvornår de skelner imellem de to. Jeg gav mig til at google lidt og fandt ud af at der faktisk ikke havde været noget til at hjælpe med den slags i .NET 2.0. Heldigvis til min store glæde fandt jeg ud af at der er dukket en ny klasse op i .NET 3.5 som er en af de små tilføjelser man ikke har hørt så meget om da det meste af snakken har omhandler større ting som eksmepelvis LINQ. Klassen hedder TimeZoneInfo, og den indeholder både metoder til at trække information ud om de forskellige tidszoner, men den indeholder også en metode til at konvertere fra UTC til lokaltid. Det eneste man skal gøre er at gemme ens datoer ved hjælp af DateTime.UtcNow eller i Sql via GetUtcDate(), og så sætte Kind på DateTime objektet til UTC når man hiver det ud af eksmepelvis en database hvor kind informationerne går tabt. Ellers håndterer metoden ConvertTimeBySystemTimeZoneId konverteringen for en, så hvad er i kort tid lignede en "tip of the iceberg" opgave hvor det ser nemt ud men der stikker mere under, blev i virkeligheden pludselig meget overskuelig at have med at gøre. Tak skal du have .NET 3.5 :)

Gazelle igen!

Efter et spændende år hvor der er sket rigtigt meget i butikken, både i kraft af omstrukturering, nye metodikker og større kunder der afføder mere komplekse løsninger end tidligere er det lykkedes os igen at blive Gazelle virksomhed. Det er en titel man næppe nogensinde bliver træt af, da det viser at man er der hvor det sker.

Bøger

CLR via C# og Framework design guidelines blev jeg nærmest provokeret til at læse da John Robbins skrev i sin bog "Debugging Microsoft .NET 2.0 Applications" at de to bøger var must read hvis man ville kalde sig selv .NET udvikler. Selvom det selvfølgelig er en provokation vil jeg gerne støtte op om den, da det er nogen bøger der giver noget essentiel viden henholdsvis om hvordan CLR'en er skruet sammen og om "best practices".

Jeg ender tit med at diskutere vigtigheden af best practices med folk, men en vigtig parameter i at skrive god kode (læs: “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” -Martin Fowler) er nu engang konformitet så man undgår misforståelser. Og hvem ved mere om best practices i frameworket end de folk der har udviklet det?

De næste bøger jeg selv har planer om at kaste mig over bliver "Introducing Microsoft Silverlight 2.0, 2nd Edition", "Professional ASP.NET 3.5: In C# and VB" og "LINQ in Action" som jeg netop har bestilt hjem. Især Silverlight bliver interessant for alvor at komme igang med, hvor de andre bøger mere er nogen jeg håber kan give lidt supplerende viden om .NET 3.5 og LINQ - hvorefter deres hovedformål bliver at fungere som opslagsværker.

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:

Who am I?

My name is Christian Holm Nielsen, 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.

Month List