Computer Science Experimentation

Sunday, March 18, 2012

Real-time Computational Engine with F#

Real-time systems require computational engines to process tasks. These engines usually are connected to data servers.

This paper presents an engine with the following properties:
  • Agents-based computation (components communicate to each other through messages)
  • Agents are state-machines
  • Agents communicate in an asynchronous mode
  • Waiting agents don’t block computer treads (asynchronous programming)
  • Engines live in an interactive environment
  • Engines of agents are distributed allowing messages from remote locations
The advantages of this implementation are:
  • Agents can be created, modified and ended without requiring restarting the process.
  • Uses F# interactive environment (Read, Evaluate, Print Loop (REPL). This allows interaction and modification of agents without stopping the process.
  • Remote clients can send messages to the engine’s agents including creating and ending agents.
  • Remote clients can use several communication protocols, available in WCF, to communicate with the engine including pipes, TCP and HTTP.
  • Asynchronous programming provides great performance and scalability.
Check the the full paper at skydrive.

    Sunday, February 12, 2012

    Web charts and F# services


    Celso Axelrud (interpoaaustin@hotmail.com)

    2/11/2012

    INTRODUCTION


    The following solution shows how to create web pages containing charts. 
    The charts are created using dygraphs JavaScript Visualization Library.
    dygraphs is an open source JavaScript library that produces interactive, zoomable charts of time series. It is designed to display dense data sets and enable users to explore and interpret them (http://dygraphs.com/index.html ).

    An F# script is used to define programmatically a self-hosted server using WCF-REST.
    The service generates sequences of random data.

    EXAMPLE

    This simple example includes a HTML5 page. A button is used to calls a web service that generates time-series data. The data is displayed it on a chart.
    An F# script is used to define programmatically a self-hosted server using WCF-REST.
    The service has the signature http://localhost:8000/charts/Get(X1,X2)
    where X1 is the number of rows and X2 is the number of sequences generated.

    Starting from the current time-stamp, the service adds one day for every row. Random data is generated for the data series.
    Even though the example is quite simple, it is quite generic because it includes all the important parts.

    The client uses HTML5, javascript and jquery. The communication uses AJAX technology.

    Check the full article and code at

    https://skydrive.live.com/?cid=BDC87EF39B001785&id=BDC87EF39B001785%21306#!/view.aspx?cid=BDC87EF39B001785&resid=BDC87EF39B001785%21328



    Saturday, January 28, 2012

    Excel Web Apps web page mash-up using F# services

    Celso Axelrud (interpoaaustin@hotmail.com)
    1/24/2012


    INTRODUCTION

    The following solution shows how to create your own web pages that mash-up Excel Web Apps with other content including web services that can operate, as reading and writing, on the Excel cells.  

    For example, this solution allows continuous update of values on Excel from several data sources providing dynamic behavior for formulas and charts.

    Also, the Excel worksheet, in the dynamic web page, is operational and can be modified by the user including new formulas and charts. Then, it can be saved for future use.

    Details about the Excel Web Apps mash-up are available at http://www.excelmashup.com/.

    The solution allows users to design their web pages in Excel either in personal computer or in the cloud at Skydrive. The Excel workspace can include all features available in the Web Apps including several sheets, formulas and charts.
    The full artircle, including example and source code, is available at:

    Thursday, December 15, 2011

    Silverlight and F#

    The following example is a Silverlight application using F#.

    The server and client are written in F# (except for a standard one line code in C# to register the event handlers). So, basically, only one language is used for all parts.

    The UI is separated from the logic and it is developed using Visual Studio XAML editor (WYSIWYG).

    The application is a simple Hello-World using a Button and a TextBlock.

    But, the example is quite generic because it allows cross-domain network access. It means that the web-page and the web-service can be hosted by multiple and different servers.

    The client solution is composed by three projects, one Silverlight Application (C#), one Silverlight Class Library (C#) and one F# Library, as follow.

    An F# script is used to define programmatically a self-hosted server. Check the full article at:

    https://skydrive.live.com/#!/view.aspx?cid=BDC87EF39B001785&resid=BDC87EF39B001785%21285

    Thursday, June 9, 2011

    WCF Excel Client using F#/Excel Automation

     
    These previous posts presented examples of a data/historian server using WCF and F#:
    This post extends these examples with a WCF Excel client using F#/Excel Automation.

     
    Check the following link for documentation and script code:
    http://cid-bdc87ef39b001785.office.live.com/view.aspx/Fsharp/WCF%5E_Excel%5E_Client%5E_1.docx

    Monday, May 23, 2011

    Data and Historian Service using WCF and F# interactive - rev 2

    This blog presents the revision 2 from the material from the blog:
    WCF with F# interactive – Data Server example - Dec/25/2010
    http://caxelrud.blogspot.com/2010/12/wcf-with-f-interactive-data-server.html
    These are the improvements:
    - The data value is of type Object. The examples show how to work with basic types as float, integer, strings and other types as dateTime. It can also use array of the basic types.
    - The data server also stores status and time-stamp.
    - The data server optionally can operate as a historian using an in-memory circular buffer storing values (objects), status and time-stamps.

    Check the code and examples at:
    http://cid-bdc87ef39b001785.office.live.com/view.aspx/Fsharp/DataServer%5E_doc%5E_1%5E_0.docx

    Thursday, May 5, 2011

    F# interactive - how to hide/show the console

    The F# interactive allows great object visibility and interactive capabilities even in running applications like server processes. So, it is a good idea to keep the F# interactive console available even in production versions of the code. But, it is not acceptable to leave several consoles open in the computer screen. The idea of this document is to show that consoles can be hidden and be shown as needed.
    The following code shows how to manage application (start) and hide/show the F# interactive console applications.

    //module ApplMgm
    
    open System
    open System.Diagnostics
    open System.Collections.Generic
    open System.Runtime.InteropServices;
    
    System.Console.Title<-"AppMgm"
    
    [< dllimport("user32.dll")>]
    extern IntPtr FindWindow(string lpClassName,string lpWindowName);
    [<dllimport("user32.dll")>]
    extern bool ShowWindow(IntPtr hWnd, int nCmdShow)
    
    let fsharpPath= @"C:\Program Files (x86)\Microsoft F#\v4.0\fsi.exe"
    
    type Process={Path:string;ExecName:string;ConsoleName:string}
    
    type AppMgm()=
        let mutable applications= new Dictionary()
        let fsharpPath= @"C:\Program Files (x86)\Microsoft F#\v4.0\fsi.exe"
    
        member this.Apps with get() = applications and set a = applications <- a
        member this.fsharpFullPath= @"C:\Program Files (x86)\Microsoft F#\v4.0\fsi.exe"
        member this.start(keyName:string) =
            let procPath=applications.[keyName].Path
            let procName=applications.[keyName].ExecName
            Process.Start(fsharpPath,@"--readline+ --load:"+"\""+procPath+procName+"\"") |>ignore
            ()
        member this.hide(keyName:string) =
            let consName=applications.[keyName].ConsoleName
            let hWnd = FindWindow(null, consName) 
            if (hWnd <> 0n) then
                let b1=ShowWindow(hWnd, 0); // 0 = SW_HIDE
                ()        
        member this.show(keyName:string) =
            let consName=applications.[keyName].ConsoleName
            let hWnd = FindWindow(null, consName) 
            if (hWnd <> 0n) then
                let b1=ShowWindow(hWnd, 1); // 1 = SW_SHOWNORMA
                ()        
    //--------------------------------------------------------------------------------------------------
    //Configuration
    let A= new AppMgm()
    let d= new Dictionary()
    let projPath= @"C:\Users\caxelrud\Documents\Visual Studio 2010\Projects\Utilities\"
    
    d.Add("ap1",{Path=projPath;ExecName="app_1.fsx";ConsoleName="Application1"})
    d.Add("ap2",{Path=projPath;ExecName="app_2.fsx";ConsoleName="Application2"})
    //d.["ap2"]
    A.Apps<-d
    //A.Apps
    
    A.start("ap1")
    A.hide("ap1")
    A.show("ap1")