Valdis Iljuconoks : F#

Schedule

valdis.iljuconoks — Wed, 18 Apr 2012 21:09:00 GMT

Kā izrādās, tad aprīļa pašas beigas un maija mēnesis izvērties par diezgan aizņemtu laika posmu. Katrā ziņā, var noķert mani kaut kur tur

Aprīlis 2012:

2012.04.26: Transporta un Sakaru Institūts:

18:15 – 19:15 “MSF & Agile”

19:15 – 19:45 “TFS 2012 Overview (Dev ‘11)”.

Maijs 2012:

2012.05.07: Latvijas Universitāte:

18:15 – 19:15 “Parallel Computing in Visual Studio 2010”

2012.05.08: Vidzemes Augstskola:

10:00 – 10:55 “Asp.Net MVC”

11:00 – 11:55 “Funkcionālā programmēšana - F#”

12:00 – 12:55 “Visual Studio 2012 - What's new?”

13:00 – 13:55 “Requirements Management in TFS”

2012.05.14: Latvijas Universitāte:

18:15 – 19:15 “Funkcionālā programmēšana - F#“

2012.05.17: Ventspils Augstskola:

11:00 – 11:45 “Designing Software Architecture in VS 2010”

12:45 – 13:30 “C# 3.0 & C# 4.0”

13:40 – 14:25 “MSF & Agile”

14:35 – 15:20 “Requirements Management in TFS”

2012.05.21: Latvijas Universitāte:

18:15 – 19:15 “C# 5.0 – async”

2012.05.28: Latvijas Universitāte:

18:15 – 19:15 “Ievads jQuery“

Cerams, ka noderēs!

F# priekš telefona

valdis.iljuconoks — Fri, 20 Aug 2010 15:00:09 GMT

Ja kādam patīk programmēt funkcionālajā valodā un vēl papildus arī uz tik eksotiskas iekārtas kā Windows Phone 7, tad ļoti iespējams, ka noderēs online projekta šablons, kas piedāvā abas šīs lieliskās iespējas.

Online galerijā meklējiet pēc “F# and C# Win Phone”.

Happy coding!

Pēdējais treniņa inventārs

valdis.iljuconoks — Tue, 04 May 2010 09:58:05 GMT

Līdz ar Visual Studio pēdējās versijas oficiālo iznākšanu š.g. aprīļa vidū ir pieejams arī treniņa inventārs, kas paredzēts lai efektīvāk apgūtu jaunās tehnoloģijas un iespējas, kas jaunajā studijā nav maz.

Visual Studio 2010 Training Kit ietver sevī šādas tehnoloģijas:

C# 4
Visual Basic 10
F#
Parallel Extensions
Windows Communication Foundation
Windows Workflow
Windows Presentation Foundation
ASP.NET 4
Windows 7
Entity Framework
ADO.NET Data Services
Managed Extensibility Framework
Visual Studio Team System

Pakotnes izstrādē galvenokārt ir piedalījušies eksperti no Microsoft Developer & Platform Evangelism grupas.

Pieejams – šeit.

Cerams, ka noderēs!

FSharp – mērvienību atbalsts

valdis.iljuconoks — Fri, 19 Mar 2010 16:13:53 GMT

Pētot nedaudz vairāk F# valodas konstrukcijas uzdūros interesantai lietai, kas saucās – SI sistēmas mērvienību atbalsts uzreiz tieši jau pašā valodā. Šo mērvienību atbalsts tiek pasniegts tādā veidā, ka kompilācijas laikā tiek pārbaudītas dažādas formulas un izteiksmes un pēc labākās gribas FSharp kompilators mēģinās konkrēto izteiksmi pārbaudīt. Šīs pārbaudes notiek tikai kompilācijas laikā un nekādu ātrdarbības ietekmi uz izpildes laiku neatstāj.

Tātad, lai kodā sāktu lietot mērvienības ir jādefinē vēlamais tips un jānorāda tam, ka tas ir mērvienības tips. Izdarāms tas ir ar Measure atribūta palīdzību.

// type to represent weight (kilo)
[<Measure>] type kg
// type to represent distance (meter)
[<Measure>] type m
// type to represent time (second)
[<Measure>] type s

Pēc tam ir iespējams veidot jau konkrētās mērvienības instances datus. Piemēram, varam izveidot attāluma un laika mērvienības vērtības:

let distance = 100.0<m>
let time = 7.8<s>

Pēc tipu evaluācijas konsoles logs attēlo jaunos izveidotos tipus:

> 
[<Measure>]      
type kg       
[<Measure>]       
type m       
[<Measure>]       
type s       
val distance : float<m> = 100.0       
val time : float<s> = 7.8  

Kad ir izveidoti gan tipi, gan arī mērvienības vērtības kodā var sākt rakstīt formulas un algoritmus, kas izmanto šīs mērvienības. Piemēram varam aprēķināt ātrumu kādā jābrauc kādai super-puper opel sporta astrīdai, lai nobrauktu 100m 7.8 sekundēs. Izklausās jau nereāli, bet testa piemēram būs pilnīgi pietiekoši.

let speed = (distance / time)
> 
val speed : float<m/s> = 12.82051282

Kompilācijas laikā, piemēram, tiek arī pārbaudīts vai laiku un attālumu maz var saskaitīt.

Lai pārkonvertētu to daudz saprotamākā izteiksmē, jāatceras ir augstākā matemātika no 2. klasītes un jādefinē ir vairākas konvertēšanas konstantes:

// type to represent distance (kilometer)
[<Measure>] type km
// type to represent distance (hour)
[<Measure>] type h
let kmPerMeter = 0.001<km/m>
let secPerHour = 3600.0<s/h>
 

Pēc kad ir nodefinētas konstantes varam veikt konvertēšanu no metriem sekundē uz kilometriem stundā:

let speedKph =  speed * kmPerMeter * secPerHour
> 
val speedKph : float<km/h> = 46.15384615

Protams kompilators nenoķers programmētāja loģiskās kļūdas, bet ja tiek sajaukta kāda matemātiskā operācija (piemēram, reizināšanas vietā tiek dalīts), noteikti rezultāts būs ar jocīgu datu tipu:

> speed * kmPerMeter / secPerHour;;      
val it : float<h km/s ^ 2> = 3.561253561e-06

Kā redzams, tad F# valodas iebūvētais atbalsts mērvienībām ir diezgan noderīgs gadījumos, kad tiešām ir jāveido formulas un jādod iespēja pārslēgties starp dažādām mērvienības sistēmām.

Cerams, ka noderēs!

F# spēka paka

valdis.iljuconoks — Fri, 19 Feb 2010 10:59:00 GMT

Nesen laists klajā jauna programmēšanas valodas F# spēka paka jeb Power Pack, kas apvieno dažādas interesantas un noderīgas lietas, kuras nav ietvertas standarta valodas bibliotēkās.

Neliels ieskats power pakas saturā, kas sastāv no vairākām bibliotēkām:

FSharp.PowerPack.dll
- Vairākas jaunas maināmi (immutable, atceramies, ka pēc noklusējuma F# tipi nav maināmi) datu tipi, piemēram, HashMultiMap, kā arī vairākas paplašinātās metodes, kuras sniedz funkcionālu pieejas interfeisa tādām datu struktūrām, kā piemēram, List<T>.
- Dažādi matemātiskie datu tipi (Vector, Matrix, utt).
- F# SI mērvienību definēšana izmantojot mērvienību valodas konstrukciju.

[<Measure>]      
/// hertz, SI unit of frequency       
type Hz = s^-1

- Kā arī papildinājumus Async programmēšanai, piemēram, asinhrono I/O paplašinājumus, kā arī dažādas palīdzības funkcijas.
Ir pieejams F# dokumentācijas ģenerators (FsHtmlDoc.exe).
FSharp.PowerPack.Linq.dll – piedāvā F# pieeju dažādām .Net 3.5 platformas iespējām.
- Konvertātori uz izteiksmju kokiem

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression ()      
let adder = <@ fun i -> i + 1 @>.Compile()

- Pieejams jauns query operators.

let db = new NORTHWND(connString)      
let sameCountry =       
    query <@ seq { for e in db.Employees do       
                       for c in db.Customers do       
                           if e.Country = c.Country then       
                               yield (e,c) } @>

FSharp.PowerPack.Parallel.dll – piedāvā dažādas paralēlās operācijas uz datu kopām, kuras ir jau pieejamas kā bāzes klases .Net 4.0 platformas versijā.

let nums = [|1..500000|]      
let finalDigitOfPrimes =       
    nums       
    |> PSeq.filter isPrime       
    |> PSeq.groupBy (fun i -> i % 10)       
    |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))       
    |> PSeq.toArray

Power paka pieejama šeit - http://fsharppowerpack.codeplex.com/.

Cerams, ka noderēs!

Pipelining

valdis.iljuconoks — Sun, 22 Feb 2009 21:37:05 GMT

Nosaukums nav diezko aizraujošs, bet gribēju pastāstīt par iespējams vienu no nozīmīgākajām F# valodas konstrukcijām – operatoru “|>”.

Tā definīcija ir pavisam vienkārša:

let (|>) x f = f x

No tipa definīcijas ir saprotams, ka tā ir inversā operācija, kas padotajam argumentam pielieto padoto funkciju.

Tipa definīcija ir:

val (|>) : 'a –> ('a –> 'b) –> 'b

kas nozīmē, ka funckija ar diviem argumentiem, kuras rezultāts (... –> 'b) ir otrā argumenta funckijas (... ('a –> 'b) ...) gala produkts.

No varētu dot šāda veida “fast forward” pieraksta veids? Clarity jeb koda lasāmību un uztveramību.

Īss ilustratīvs piemērs:

let add a b = a + b

let nums = [1; 2; 3; 4; 5]

let odds_plus_ten =

    List.map (add 10)

        (List.filter (fun n -> n % 2 <> 0) nums) 

Šajā piemērā definējam vispirms funkciju, kas saskaita 2 vērtības (jauki, ka F# ir tipu noteikšanas iespēja), definē sarakstu ar cipariem un katram nepāra ciparam iepriekš definētajā sarakstā pieskaita vērtību 10.

Kods izskatās pietiekoši imperatīvs, lai vairums .Net lietotāju to saprastu un pieraksts likots pazītams un ierasts.

Izmantojot lielisko “cauruļošanas” iespēju F# valodā, augstāk minētās funckijas pieraksts būtu šāds:

let odds_plus_ten =   
    nums    
    |> List.filter (fun n-> n%2 <> 0)    
    |> List.map (add 10) 

Kā rezsultātā List.filter funckija tiks izsaukta gan ar filtrēšanas funkciju, gan arī ar definēto ciparu kopu un funkcijas rezultāts tiks nodots tālāk List.map funckijas izpildei, kas izsauks ``List.map'' funkciju katram saraksta elementam.

Pieraksts varbūt ir nedaudz nepierasts un savādāks, bet, manuprāt, daudz reiz saprotamāks un lasāmāks, cik nu funkcionālais stils var būt lasāms :)

Tātad, “|>” operātors mums dod sekojošas priekšrocības:

Clarity. Ja tiek pielietots ar List.map un tamlīdzīgas klases funkcijām, datu tranformāciju un iterācijas var pierakstīt ķēdes pierakstā, kas palielina koda lasīmību.
Type inference. Pielietojot “|>” operatoru tiek panākta objektu tipa informācijas plūsma no kreisās puses, kur tiek definēts ieejas objekts, uz labo pusi – funckijām, kas manipulē ar šiem objektiem. F# pats izmanto šo informāciju, lai risinātu dažāda rakstura valodas konstrukcijas jautājumus (īpašību pieeja un metožu pārlādi).

Cermas, ka noderēs!

Kam patīk pozicionālie argumenti?

valdis.iljuconoks — Thu, 12 Feb 2009 19:29:00 GMT

Ilgu laiku mums nācies programmēt valodās, kurās pozicionālie argumenti jeb vērtības metodei tika nodotas atkarībā no pozīcijas. Jaunajā C# valodā šīs problēmas tiks atrisinātas, citās valodās laikam saglabāsies vēl ilgāku laiku - sākas ar "JA" un beidzas ar "VA" :)

Protams, ka pozicionālie argumenti metodēm rada nelielas galvas sāpes šo metožu radītājiem, kas kopsummā padara kodu repetatīvu un grūtāk uztveramu.

Tā kā mēģinu lēnām kustēties līdzi galvenajai straumei (next wave mainstream) un interesējos intensīvāk par funkcionālās programmēšanas iespējām .Net platformā, tad šoreiz gribēju padalīties nedaudz ar informāciju, kā nosauktos un neobligātie argumenti ir realizēti F# programmēšanas valodā.

Pieņemsim, ka ir sekojošas klases:

type Address(st :string) =
    member a.Street = st

type Client(code :string, address :Address) =
    member c.Code = code
    member c.Address = addr

Klases nav pārāk sarežģītas - adrese un klients.

Konstruēt jaunas instances šādam klientam ir ļoti vienkārši:

> Client ("1123456-12345", Address ("Brivibas"));;
val it : Client = FSI_0004+Client {Address = FSI_0003+Address;
Code = "1123456-12345";}

Ideāli būtu ja varētu šai klasei ieviest neobligātos parametrus, ja nu pēkšņi kādam ievajagās klientu ar noklusēto adresi, kas gan diezvai kādam būs noderīgs :)

Lai ieviestu klienta klases konstruktoram neobligātos parametrus (un patiesībā arī nosauktos parametrus), ir nepieciešams tipa definīcijas parametros ieviest "?" simbolu, kas pazīmē, ka parametru var arī nenorādīt tipa konstruēšanas laikā.

Jaunais tips izskatās šāds

type Address(st :string) =
    member a.Street = st

type Client(?code :string, ?address :Address) =
    let code = defaultArg code ""
    let addr = match address with
                   | None -> new Address("")
                   | Some a -> a
    member c.Code = code
    member c.Address = addr

Tātad par veiktajām izmaiņām visu pēc kārtas:

Pirms parametra nosaukuma tika pievienots "?" simbols, kas definē, ka parametrs ir neobligāts.
Tipā tika ieviesti divi papildus mainīgie parametru vērtību aprēķināšai.
Funkcija defaultArg dod iespēju pārbaudīt un piešķirt vērtību kādam mainīgajam, ja parametrs netika norādīts (kaut kas līdzīgs var i = (p != null ? p : -1)). Šī funkcija darbojas tikai uz vienkāršajiem tipiem.
Otrs parametrs, kas ir kompleksais (cits tips - Address) tipa ķermenī tiek reprezentēts kā option, kura vērtība var iegūst pielietojot pattern matching ideoloģiju F# programmēšanas valodā (par šo veidu noteikti pastāstīšu kādā no nākamajām reizēm).

Tātad izveidojām tipu ar neobligātajiem parametriem, kura definīcija ir sekojoša:

type Client =
class
    new : ?code:string * ?address:Address -> Client
    member Address : Address
    member Code : string
end

Kā redzams, tad jauna tipa izveide ir iespējama ar neobligātajiem parametriem, kuri tipā tiek reprezentēti kā ?address:Address, kas nozīmē, ka parametrs ir option tipa.

Jaunu instanci izveidot ir pavisam vienkārši:

> Client();;

val it : Client = FSI_0006+Client {Address = FSI_0003+Address;
Code = "";}

Šajā gadījumā noklusēto vērtību iegūst abi argumenti.

> Client(address = Address("Brivibas"), code = "123456-12345");;

val it : Client = FSI_0006+Client {Address = FSI_0003+Address;
Code = "123456-12345";}

Kā redzams, tad neobligāto pparametru nodošanas pieraksts ir stipri līdzīgs, kādu mēs sagaidām no jaunās C# valodas versijas. Jauki redzēt, ka šī iespēja ir iestrādāta F# OO sadaļā jau no paša sākuma.

Centīšos cik vien laiks atļauj mēģinām lēnām iepazīstināt Jūs ar šīs valodas konstrukcijām un iespējām. Tā tak nevar būt, ka Microsoft kļūdās, par nākamās paaudzes un nākamā viļņa tehnoloģijām un rīkiem, ko pēc pāris gadiem visi izmantos un visiem darba devējiem būs aktuāli (ja vien nebūsim jau ekonomiskās krīzes nobeigti...)

Cerams, ka noderēs!

Jaunais vilnis - paplašinājuma īpašības

valdis.iljuconoks — Fri, 21 Nov 2008 20:40:00 GMT

Sveicināti atkal,

Pētot sarakstu ar iespējām, ko Microsoft izstrādātāji ir ieplānojuši izdarīt ar C# 4.0 un VB 10 versijām (tās beidzot varētu teikt, ka saņems vienādu feature-set), ieraudzīju vienu palaistu garām feature - Extension Properties. Piekrītu dažiem, ka paplašinājuma metodes (ieraksti - 1, 2) rada sava veida apjukumu un disorientāciju kodā, piekrītu arī citiem, kas tas paver plašas paplašinājuma iespējas savam un kādam citam kodam.

Tomēr šķiet, ka C# trešās versijas jaunievedums, kas deva paplašināt metodes, šķiet nedaudz nepabeigts bez paplašinājuma īpašībām, statiskajiem klases locekļiem vai pat paplašināmiem klases notikumiem.

Par cik man darbs ir sajūsmināties un iedegties par visām jaunajām iespējām un platformām un galvenais argumentēti un pārliecinoši to pasniegt priekšniecībai, jo tikai tādā veidā notiek kaut kāds progress nevis stagnācija tehnoloģiskajā jomā, tad nu šoreiz kārta ir programmēšanas paradigmai, kas bija ļoti populāra pāris dekādes atpakaļ - funkcionālajai programmēšanai. Šoreiz runa ir par .NET 4.0 jaunpienācēju - F#.

Nedaudz apgūstot F# pamatus sapratu, ka paplašinājuma īpšības nodefinēt tipam F# programmēšanas valodā ir tikpat vienkārši, kā nodefinēt jaunu tipa locekli (member).

Tātad, uzsākot mūsu mazo eksperimentu, mums ir jānodefinē vārdu telpa

namespace Int32Extensions

Pēc tam ir jādefinē pats tips (klase):

module Int32Extensions =

    type System.Int32 with

        member this.DivFromTen

            with get() =

                10 - this

Šim jaunajam tipam jeb klasei ir jauns loceklis, kas definē jaunu īpašību (with get()) System.Int32 tipam jeb klasei. Konkrēti jaunā īpašība aprēķina "attālumu" līdz skaitlim 10.

Pozitīvi ir arī tas, ka jaunie definētie locekļi parādās arī bez problēmām gudrajā pārlūkotajā - IntelliSense.

Un lūk arī rezultāts augstāk minētajām 2 rindiņām:

>
val int : int

Div - 5

Jāpiemin, ka diemžēl šīs konstrukcijas nav pieejamas citās valodās, piemēram, C# :(

Būtu jau jauki, ja mēs varētu uzrakstīt kodu apmēram šādu:

var past = 2.Minutes.Ago;

Cerams, ka noderēs!

_____________________________