Learning in progress

WPF Dynamic Data Display.

Kishor Aher — Fri, 04 Dec 2009 14:51:32 +0000

Found this amazing library for dynamic data display developed by Computational Science Laboratory in Microsoft Research. It features efficient binding mechanisms and real-time interactivity capable of charting millions of data points. WPF developers in finance should have a look at this.

http://www.codeplex.com/dynamicdatadisplay

CSLA.Net framework for developing business objects.

Kishor Aher — Sat, 21 Nov 2009 16:43:43 +0000

I have been fan of CSLA.Net(component-based, scalable, logical architecture) framework since early days of my career had ported it from VB.Net to C# then. This framework comes handy for development of N-Tier architecture. Following are the feature highlights.

Tracking Broken Business Rules
Tracking Whether the Object Has Changed
Strongly Typed Collections of Child Objects
Simple and Abstract Model for the UI Developer
Supporting Data Binding
Object Persistence and Object-Relational Mapping .
Business Object Creation
N-Level Undo Functionality
Data Binding Support
Validation Rules
Data Portal
Custom Authentication
Integrated Authorization

http://www.lhotka.net/

Finally WPF/Sliverlight style generator.

Kishor Aher — Fri, 02 Oct 2009 04:16:10 +0000

I started this project last week and so far i was able to get Monochromatic, complimentary, Triad , Tetrads and analogous colors. The final goal of this project are as follows.

User should be able to view dark and light style with chosen color on predefined template.
User should be able to generate ResourceDictionary for Silverlight/WPF out of the chosen color. (This would relieve every developer from pain of styling the application trust me i know it)

Coming soon on codeplex……. Download code.

Note: Please contribute to the project for the wellbeing of all the developers

Microsoft Security Essentials

Kishor Aher — Tue, 29 Sep 2009 15:55:54 +0000

Microsoft Security Essentials provides real-time protection for your home PC that guards against viruses, spyware, and other malicious software. It is available for free, for Windows XP 32-bit, Windows Vista/7 32-bit, and Windows Vista/7 64-bit.

http://www.microsoft.com/security_essentials/

Project Tuva from microsoft research.

Kishor Aher — Fri, 18 Sep 2009 03:01:40 +0000

http://research.microsoft.com/apps/tools/tuva/index.html

Microsoft research project tuva home page explains it like this:

“Project Tuva explores core scientific concepts and theories through presenting timeless videos with its new enchanced Video Player featuring searchable video, linked transcripts, notes, and interactive extras”

It was amazing to see and hear Dr. Richard Feynman’s lecture on “Law of Gravitation” at Cornell University in 1964.

Why functional programming?

Kishor Aher — Thu, 17 Sep 2009 01:56:05 +0000

Functional programming is not a silver bullet, but learning it will indeed add to the knowledge of every software engineer about solving problem in different a way. One can always implement functional style of programming in any imperative language they use.

Advantages:

For analysis of mathematical problem that requires human analysts, it is possible to represent the problem in a concise mathematical form that analysts can understand.
A declarative language simplifies the creation and multiple interpretations and static analysis.
Compositional construction allows natural mapping of the problem domain and encourages code reuse.
Functional programming language like haskell makes maintenance easy due to its high level of abstraction which also makes addition of new features a lot simpler then it would be in any imperative language.
As most of the data types in functional languages are immutable concurrency and parallelism is integral art of the language. Most modern functional languages like Haskell and Erlang support multi-core without any extra libraries.
Its easy to implement domain-specific language.

Disadvantages:

Its difficult to get developers on functional languages and thus it adds to project risk.
UI development is not a proven ground in functional world.
Performance is real unknown for most functional languages as its not widely accepted in developing of large real time systems. Haskell performance. (i personally believe that with multi-core systems any problem needs to be parallelized and immutability is the only answer to that type problems. So even imperative languages have to make data structures immutable to solve the problem on multi-core.)

Here is the implementation of Black Scholes model for European options in Haskell and C#. I wrote this example to show the difference between functional and imperative language, see it your self.

 type Put = String
 type Call = String
 data Option = Call | Put
 deriving (Eq, Show)
 blackscholes :: Option -> Double -> Double -> Double -> Double -> Double -> Double
 blackscholes  option s x t r v
 | option == Call = s * normcdf d1 – x*exp (-r*t) * normcdf d2
 | option == Put = x * exp (-r*t) * normcdf (-d2) – s * normcdf (-d1)
 where
 d1 = ( log(s/x) + (r+v*v/2)*t )/(v*sqrt t)
 d2 = d1 – v*sqrt t
 normcdf x
 | x < 0 = 1 – w
 | otherwise = w
 where
 w = 1.0 – 1.0 / sqrt (2.0 * pi) * exp(-l*l / 2.0) * poly k
 k = 1.0 / (1.0 + 0.2316419 * l)
 l = abs x
 poly = horner coeff
 coeff = [0.0,0.31938153,-0.356563782,1.781477937,-1.821255978,1.330274429]
 horner coeff base = foldr1 multAdd  coeff
 where
 multAdd x y = y*base + x

 namespace BackScholes
 {
 class Program
 {
 static void Main(string[] args)
 {
 }
 }
 enum Option
 {
 Call,
 Put
 }
 /// 
 /// Summary description for BlackSholes.
 /// 
 public class BlackSholes
 {
 public double BlackScholes(Option option, double S, double X,
 double T, double r, double v)
 {
 double d1 = 0.0;
 double d2 = 0.0;
 double dBlackScholes = 0.0;
 d1 = (Math.Log(S / X) + (r + v * v / 2.0) * T) / (v * Math.Sqrt(T));
 d2 = d1 – v * Math.Sqrt(T);
 if (option == Option.Call)
 {
 dBlackScholes = S * CND(d1) – X * Math.Exp(-r * T) * CND(d2);
 }
 else if (option == Option.Put)
 {
 dBlackScholes = X * Math.Exp(-r * T) * CND(-d2) – S * CND(-d1);
 }
 return dBlackScholes;
 }
 public double CND(double X)
 {
 double L = 0.0;
 double K = 0.0;
 double dCND = 0.0;
 const double a1 = 0.31938153;
 const double a2 = -0.356563782;
 const double a3 = 1.781477937;
 const double a4 = -1.821255978;
 const double a5 = 1.330274429;
 L = Math.Abs(X);
 K = 1.0 / (1.0 + 0.2316419 * L);
 dCND = 1.0 – 1.0 / Math.Sqrt(2 * Convert.ToDouble(Math.PI.ToString())) *
 Math.Exp(-L * L / 2.0) * (a1 * K + a2 * K * K + a3 * Math.Pow(K, 3.0) +
 a4 * Math.Pow(K, 4.0) + a5 * Math.Pow(K, 5.0));
 if (X < 0)
 {
 return 1.0 – dCND;
 }
 else
 {
 return dCND;
 }
 }
 }
 }

Dryad and DryadLinq release for academic community.

Kishor Aher — Sun, 19 Jul 2009 17:01:13 +0000

Microsoft’s answer to google map reduce and hadoop for distributed computing is Dryad.

http://research.microsoft.com/en-us/collaboration/tools/dryad.aspx

RoutedEvent to Command action behavior (Blend 3).

Kishor Aher — Sat, 18 Jul 2009 18:34:16 +0000

Blend 3 has added two new assemblies which consists of new functionalities including advance behaviors

Microsoft.Expression.Interactions.dll
System.Windows.Interactivity.dll

These advance behavior classes lets you create attached behaviors with simplicity. Code snippet below shows how to create a behavior which can be applied on any UIElement’s Routed event and when that event is triggered the given command is invoked with its command parameters. These behaviors help us write clean code and we dont have to deal with click events when using M-V-vM pattern. We can wite our command and bind that command to any routed event on any user interface element and implement the command on view model.

Code Snippet

 using System;
 using System.Windows;
 using System.Windows.Input;
 using System.Windows.Interactivity;
 using EventTrigger = System.Windows.Interactivity.EventTrigger;
 namespace Behaviors
 {
 /// 
 /// Behaviour helps to bind any RoutedEvent of UIElement to Command.
 /// 
 [DefaultTrigger(typeof(UIElement), typeof(EventTrigger), "MouseLeftButtonDown")]
 public class ExecuteCommandAction : TargetedTriggerAction
 {
 /// 
 /// Dependency property represents the Command of the behaviour.
 /// 
 public static readonly DependencyProperty CommandParameterProperty = DependencyProperty.RegisterAttached(
 “CommandParameter”,
 typeof(object),
 typeof(ExecuteCommandAction),
 new FrameworkPropertyMetadata(null));
 /// 
 /// Dependency property represents the Command parameter of the behaviour.
 /// 
 public static readonly DependencyProperty CommandProperty = DependencyProperty.RegisterAttached(
 “Command”,
 typeof(ICommand),
 typeof(ExecuteCommandAction),
 new FrameworkPropertyMetadata(null));
 /// 
 /// Gets or sets the Commmand.
 /// 
 public ICommand Command
 {
 get
 {
 return (ICommand)this.GetValue(CommandProperty);
 }
 set
 {
 this.SetValue(CommandProperty, value);
 }
 }
 /// 
 /// Gets or sets the CommandParameter.
 /// 
 public object CommandParameter
 {
 get
 {
 return this.GetValue(CommandParameterProperty);
 }
 set
 {
 this.SetValue(CommandParameterProperty, value);
 }
 }
 /// 
 /// Invoke method is called when the given routed event is fired.
 /// 
 /// 
 /// Parameter is the sender of the event.
 /// 
 protected override void Invoke(object parameter)
 {
 if (this.Command != null)
 {
 if (this.Command.CanExecute(this.CommandParameter))
 {
 this.Command.Execute(this.CommandParameter);
 }
 }
 }
 }
 \

Once you create a class with the above code and open the project in blend and open any UI, you can see the following view in the asset tab. Marked in red is our behavior.

Drop the behavior onto any UIElement

Finally you can see how we can select the Event and bind the command and command parameters in the properties tab.

XAML for above blend designer setting.

Code Snippet

 <Grid> 
 <i:Interaction.Triggers>
  <i:EventTrigger EventName=”MouseLeftButtonDown”>
  <Behaviours:ExecuteCommandAction Command=”{Binding MyCommand}” CommandParameter=”{Binding MyCommandParameter}”/>
  i:EventTrigger>
  i:Interaction.Triggers> 

Design time support for Prism.

Kishor Aher — Wed, 01 Jul 2009 13:33:51 +0000

As we all know that Designer-Developer workflow is not feasible when the application is developed in Prism (Composite Application Guidance). Prism requires each use case to have it’s functionality in different modules and load these modules at run-time.

Due to runtime loading of the user control neither Visual Studio or Blend can be used for implementing designer-developer workflow as the user interface cannot be seen in its entirety.

Here is what i implemented with the help of Marc Jacobs . We create an attached behavior that can be set on any ContentControl or ItemsControl. This attached behavior takes the user control which we need to display while design-time.

Code Snippet

 public static void OnContentChanged(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
 {
 if (DesignerProperties.GetIsInDesignMode(depObj))
 {
 var contentControl = depObj as ContentControl;
 if (contentControl != null)
 {
 contentControl.Content = e.NewValue;
 }
 else
 {
 var itemsControl = depObj as ItemsControl;
 if (itemsControl != null)
 {
 itemsControl.Items.Add(e.NewValue);
 }
 }
 }
 \

The magic happens in the OnContentChanged method, when we set the attached behavior content this method is invoked. The code inside the method only inserts the user control in the design mode.

Code Snippet

 <Window x:Class=”DesignTimePrism.ShellView”
  xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
  xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
  xmlns:cal=”http://www.codeplex.com/CompositeWPF”
  xmlns:local=”clr-namespace:DesignTimePrism”
  xmlns:menu=”clr-namespace:DesignTimePrism.Modules.Menu;assembly=DesignTimePrism.Modules.Menu”
  xmlns:main=”clr-namespace:DesignTimePrism.Modules.Main;assembly=DesignTimePrism.Modules.Main”
  Title=”Window1″ Height=”600″ Width=”600″>
  <Window.Resources>
  <main:MainView x:Key=”mainView” />
  <menu:MenuView x:Key=”menuView” />
  Window.Resources>
  <Grid>
  <Grid.ColumnDefinitions>
  <ColumnDefinition Width=”0.3*” />
  <ColumnDefinition Width=”0.7*” />
  Grid.ColumnDefinitions>
  <ContentControl Grid.Column=”0″
  local:DesignTime.Content=”{StaticResource mainView}”
  cal:RegionManager.RegionName=”MenuRegion” />
  <ContentControl Grid.Column=”1″
  local:DesignTime.Content=”{StaticResource menuView}”
  cal:RegionManager.RegionName=”MainRegion” />
  Grid>
 Window>

The only downside of using this technique is having the user controls declared in the resource dictionary. Also below are the snapshots of the application in design and runtime mode.

Design time snapshot	Runtime snapshot

Code DesignTimePrism.zip

Interactive Programming Flapjax

Kishor Aher — Wed, 24 Jun 2009 14:18:46 +0000

Flapjax is a new programming language based on interactive programming model. It is build as a framework on javascript and thus works with any web browser.

Its principal features include:

Event-driven, reactive evaluation
An event-stream abstraction for communicating with web services
Interfaces to external web services

http://www.flapjax-lang.org/