Somewhere between Primal and Dual

Sierpinski‘s Triangle

2010-05-16T08:00:00.000-07:00

I am enjoying reading the book The Haskell School of Expression. This book teaches Haskell using graphics, multimedia, and so forth. Indeed, it is an interesting approach to teach a functional programming language than Fibonacci series and factorial numbers. After reading the chapter 2 “ Simple Graphics “, I tried to transcript the source code in F#. Boy, I must tell you, I ran into problems. I tried with WPF and F# and it seems to be not a happy marriage. After trying out several things, I chose DirectX and Winforms...Please read more www.paul-abraham.com/Sierpinski.doc

Caesar Cipher in F# and Haskell

2009-12-24T10:46:00.000-08:00

The roman empire Julius Caesar (100 B.C - 44 B.C) used very simple encipher method to communicate with troops. This method substitutes each alphabet of a word with an alphabet from certain position further in alphabet system. If we use displacement-length 2 for the word “apple”,we will get “crrng”. This cipher method is very easy to crack because we have to check only 25 combinations and every language has characteristic distribution for its alphabets, just like finger print.
please read more www.paul-abraham.com/CaesarCipher.doc

Implementing Generic Algorithms in Functional Languages

2009-10-26T10:23:00.000-07:00

Haskell has the status like Hebrew ,Latin ,or Greek in the natural languages. Knowledge of Haskell will help you understand concepts of functional programming. I am profiting very much Haskell lectures which gave by Erick Meijer.
http://channel9.msdn.com/shows/Going+Deep/C9-Lectures-Dr-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-4-of-13/
Generic functions increase reusability and composability . Let us start with the small example and we want write a function that gives biggest element of a given tuple. Well, if we implement this function Haskell.
Please read more: http://www.paul-abraham.com/GenericAlgorithms.doc

Is It An Interpretation or Revelation?

2009-06-28T18:42:00.000-07:00

In my Life, I heard many times "Coriolan" Overture " (Beethoven), but this interpretation is a magic . Here comes maestro Carlos Kleiber to conduct :
http://www.youtube.com/watch?v=KB_-zFcy-hM&feature=related
Enjoy

State Monad in F#

2009-06-02T22:19:00.000-07:00

I watched Brain Beckman's Web Cast "The Zen of Stateless State"
http://channel9.msdn.com/shows/Going+Deep/Brian-Beckman-The-Zen-of-Expressing-State-The-State-Monad/
and wrote example code for State Monad in F#. Please Check
http://www.paul-abraham.com/MonadsInFSharp.doc

iPod=Horse

2009-04-28T19:32:00.000-07:00

Now, I know, why I don't have an iPod. Thank you Maestro Riccardo Mutti for valuable Insights:)
http://www.youtube.com/watch?v=2fyUGY5i9aQ

Enjoy
http://www.youtube.com/watch?v=-AgfCW4r82A

http://www.youtube.com/watch?v=Xvdig4N0bpk :)

Concurrent Quicksort in Erlang and F#

2009-04-09T10:56:00.000-07:00

Moore’s Law is no more applicable ( http://en.wikipedia.org/wiki/Moore's_law ) since processors are not getting faster and faster. We have now multicore-processors and developers are confronted with new reality. There are dedicated frameworks like Parallel Extension ,Task Parallel Library(by-product of Microsoft Robotics) for Microsoft.net or dedicated programming languages such as Erlang, but the crucial ingredient for success is to modify algorithms to work parallel as possible. We can gauge achieved improvements by applying Amdahls Law(http://en.wikipedia.org/wiki/Amdahl). I am going to implement these algorithms in F# and Erlang.
Please read more www.paul-abraham.com/ConcurrentProgramming.doc

A Giant Rock

2009-03-22T00:42:00.001-07:00

Do I need to use synchronize primitives in F# MailboxProcessor ?

2009-03-22T00:21:00.000-07:00

We don’t need any synchronizing primitives or additional synchronizing efforts to use F# Mailboxprocessor. I like to share a simple program which demonstrates that you don’t need care about synchronizing issues. Read more ....
www.paul-abraham.com/FSharpMailboxProcessor.doc

Data Abstraction in F#

2009-02-22T09:07:00.000-08:00

Data abstraction deals with the question, how to compose compound data from primitive types. SICP states : Data abstraction is a methodology that enables us to isolate how a compound data object is used from the details of how it is constructed from primitive data object. We will firstly implement a solution which is similar to the SICP text book (http://mitpress.mit.edu/sicp/). It uses tuples as primitive data structure. Indeed, tuples are very straightforward and powerful primitive data structure in functional programming ,but on the other hand, we have to consider, whether these primitives are suitable for .Net platform in the era of SOA or cloud computing.
Please check http://www.paul-abraham.com/FSharpCode2SICP.doc to get the whole series .

Mendelssohn's Workroom

2009-02-16T07:57:00.000-08:00

This is the work-room of Felix Mendelssohn. I visted his home Leipzig . He wrote Elias in this room,yeah , a small room;but, with great impact:)

WCF F# Examples

2009-02-14T23:12:00.000-08:00

I like to share some WCF Examples which I have implemented in FSharp . I am going touch aspects of WCF by giving examples.

Example 1 15.02.2009
I like to show you in this example to setup a basic WCF service programmatically. We will add two channels(web service and tcp/ip) and enable metadata behavior which allows users to create proxy clients.
Download the source code(www.paul-abraham.com/FSharpWCFSimple1.zip) and compile it in shell command. Open the test client proxy by typing:
wcftestclient http://localhost:2008/SimpleService.

Read more www.paul-abraham.com/WCFProgrammingWithFSharp.doc

Domain Specific Languages with F#

2009-01-05T13:17:00.000-08:00

Sourcecode: www.paul-abraham.com/DSLPolynomial.zip
Domain Specific Language (DSL) is a programming language which is applied on a specific area. Domain Specific Languages have habitually very small syntax and offers limited expressions, consequently it is very easy to learn and the user can focus on solving a problem rather than learning a fully fledged language. Pattern matching capabilities of F# and tools for parsing (fsyacc.exe) & lexing(fslex.exe) allow you create own DSL effortlessly. Martin Fowler has written a profound article in this subject (http://martinfowler.com/dslwip/UsingDsls.html).
read more www.paul-abraham.com/DSLPolynomial.doc

Mutual Recursion in F#

2008-12-07T08:07:00.001-08:00

Mutual recursion is an important concept in functional programming. It is useful if two function need to call each other. In the following example, I am calculating Fibonacci numbers in straight and mutual recursive fashion:
#light
// Straight Version
let rec fibonacci(n) =
if n<1>=0 "))
if n <=2 then 1 else fibonacci(n-1)+fibonacci(n-2)

let n=fibonacci(8)
printfn "%d" n

// mutual recursion version
let rec f(n)= if n=1 then 1 else g(n-1)
and g(n)= if n=1 then 0 else g(n-1)+f(n-1)

let mr_fibonacci(n)=f(n)+g(n)

let mr_d=mr_fibonacci(8)
printfn "%d" mr_d

F# LegoNxt Robot

2008-11-30T21:12:00.000-08:00

Source Code: www.paul-abraham.com/FSLego.zip

I am learning F# since 07/2007 and looked always for an opportunity to put my F# coding skills in to practice. I grabbed my son’s Lego Nxt and wrote a library in F# to communicate with Lego Nxt Brick via Blue Tooth . I have added support for two moving motors (Port B and C) , touch sensor (Port 1) and sonar sensor(Port4). Joe Armstrong (Erlang Programming Language) told in an interview something like this :
In a real world, people also act concurrently from one another and this all works fine and we don’t need to be Siamese twins with conjoined brains(hint :shared memory). I am using Erlang style Message Passing Style using F# MailboxProcessor for collecting data and to control nxt robot.
In source code , I have written an example AutonomousNxtBrick which will drive autonomic and avoid collision.

Enjoy

F# MailboxProcessor

2008-11-13T02:39:00.000-08:00

The Mailboxprocessor class has changed slightly in Version 1.9.6.2
You have to modify the example 13.11 from the Expert F# Book as following to run

#light
// ----------------------------
// Listing 13-11.
/// The internal type of messages for the agent
type internal msg = Increment of int Fetch of AsyncReplyChannel Stop
type CountingAgent() =
let counter = MailboxProcessor.Start(fun inbox ->
// The states of the message-processing state machine...
let rec loop(n) =
async { let! msg = inbox.Receive()
match msg with
Increment m ->
// increment and continue.
return! loop(n+m)
Stop ->
// exit
return ()
Fetch replyChannel ->
// post response to reply channel and continue
do replyChannel.Reply(n)
return! loop(n) }
// The initial state of the message-processing state machine...
loop(0))
member a.Increment(n) = counter.Post(Increment(n))
member a.Stop() = counter.Post(Stop)
member a.Fetch() = counter.PostAndReply(fun replyChannel -> Fetch(replyChannel))
// ----------------------------
let counter = new CountingAgent()
counter.Increment(1)
let v=counter.Fetch()
printfn "%d" v
counter.Increment(2)
let s=counter.Fetch()
printfn "%d" s
counter.Stop()

Formulation Abstractions with Higher Order Functions

2008-10-30T09:26:00.000-07:00

A function is called higher order function if it takes functions as arguments and return a function. Say, you have a family of algorithm and each of them differs from one another in some steps, but there is common basic patter. In object oriented world, you will use typically the Strategy–Pattern to tackle this kind of problem.
Please check
http://www.paul-abraham.com/FSharpCode2SICP.doc

Continuation Monad

2008-10-19T13:37:00.000-07:00

Continuation Monad plays an import role in F# . It powers Workflows. I wrote a sample code in F# and checked monadic Axioms. Please check to get entire series
( http://www.paul-abraham.com/MonadsInFSharp.doc)

Linear Recursion and Linear Iteration (Tail Recursion).

2008-10-08T14:14:00.000-07:00

Friends, I am back from Israel and I have attended there a mathematical conference. Now ,I am enjoying reading the wonderful book “Structure and Interpretation of computer Programs”. I have written F# code for Linear Recursion and Linear Iteration (Tail Recursion). Please check http://www.paul-abraham.com/FSharpCode2SICP.doc to get the whole series

List Monad in F#

2008-09-13T19:28:00.000-07:00

Now, it is time look some useful monads than Identity Monad. If you look LINQ query , you can’t miss it recognize the Bind operator(>>=) of a Monad:
public static IEnumerable SelectMany

I am using ResizeArray<_> as List, which is synonym for .Net generic list List<>. I have implemented standard Customer Order scenario to check monads Axioms:
( http://www.paul-abraham.com/MonadsInFSharp.doc)

Identity Monad in F#

2008-09-10T09:12:00.000-07:00

When I have studied Category Theory at the university , I didn’t know where to use Monads and Kleisli triple.The Whole Gadget was very abstract to me. Since I have encountered with F# Workflows and LINQ , I understand the power and elegance of Monads. In order to learn F#,I have implemented the Identity Monad.
( http://www.paul-abraham.com/MonadsInFSharp.doc)

F# Code to Structure and Interpretation of Computer programs

2008-09-03T20:38:00.000-07:00

F# Code to Structure and Interpretation of Computer programs.I love and enjoy reading the book “Structure and Interpretation of computer Programs” (http://mitpress.mit.edu/sicp/) but examples of this book are written in Lisp. Right now ,I am learning F# and I think that it is a great opportunity to acquire practice with this great language. Please check http://www.paul-abraham.com/FSharpCode2SICP.doc to get the whole series . I will add F# implementaions day by day.