February 2010 – continuous learning …

Linear Way of Thinking

When I came across with Mindmaps, I was very happy seeing there are other people in the world that thinks thinking can’t be only the lists. Your mind may want to expose the (never ending/circular) links in a different way rather than sorted lists.

If you haven’t give a chance.

I feel disappointed when I search for things, it is not I can find a file with a search keyword on a specific/whole directory, but when I want reach I file, I want to remember I create/access that file before. I am after the links most of the time, not the file.

Internet browsers in that sense are quite dissapointing. The history does list all the links. “OK, well, I know K was talking about M on his blog, and then M was talking about Z, but can’t remember the name for Z.” The history does list K, M, Z not in order that I have accessed. [I may have a time delay between my access times, could look other L, O, Y pages.]
And my memory is enough weird that I can remember exactly which date I was looking for, but not the hours. I can remember K most of the time, the starter, but then all becomes complicated.
Thanks to Mark’s blog on sketches, and Graphviz group at AT&T.
My graph is not depending on real data, but I tried to make it look sensible. The horizontal line is timeline.
As “web” is more net shaped, possible this world graph would be more realistic. But for now, this one will be enough to tell my problem for visualisation of my internet history. What is missing is “ports” that the line/word/link I moved from one site from another. And would be happy the page caches which lines I have not read.
[Yes I know, first web should log which lines my scrollbar is rolling/my mouse clicking, and it can be frustating, but will save a lot of time for me:)]

Development environments are disappointing as well. Thanks to Resharper, you can find the usage of a file, or can go to definition, so both ways you are navigate through your code in the same assembly. The problem starts with legacy codes. You want to change a sproc, and trying to findout where this could have been used. There is little chance that, your common library code accessing that sproc is duplicated in UI layer somewhere in another assembly. Well done!
When you search for a branch/directory, the result is just a list. No links/connections/dependencies.

Let’s see how I will get on with the project.

Programming Paradigms

Van Roy discusses the programming paradigms on his article, and tells the reasons behind languages, how do they behave in certain scenarios.

A programming paradigm is an approach to programming a computer based on a mathematical theory or a coherent set of principles. Each paradigm supports a set of concepts that makes it the best for a certain kind of problem.

For example, object-oriented programming is best for problems with a large number of related data abstractions organized in a hierarchy. Logic programming is best for transforming or navigating complex symbolic structures according to logical rules. Discrete synchronous programming is best for reactive problems, i.e., problems that consist of reactions to sequences of external events.
Each language realizes one or more paradigms, and each paradigm consists of a set of concepts.

He argues that there are two main properties of paradigms: having observable nondetermism and supporting state.

Having nondeterminism is when the execution of a program is not completely determined by its specification, i.e., at some point during the execution the specification allows the program to choose what to do next. During the execution, this choice is made by a part of the run-time system called the scheduler. The nondeterminism is observable if a user can see different results from executions that start at the same internal configuration.

This expressive power can be used to model real-world situations and to program independent activities, whereas it makes lif hard to use it for concurrent programming [especially in Java]. For concurrent programming, declarative concurrent paradigm is preferable, in which all programs are deterministic.

Three axeness of expressiveness are: state is named or unnamed, deterministic or undeterministic, sequential or concurrent.

The least expressive combination is functional programming (threaded state, e.g., DCGs in Prolog and monads in functional programming:
unnamed, deterministic, and sequential).
Adding concurrency gives declarative concurrent programming (e.g., synchrocells: unnamed, deterministic, and concurrent). Adding nondeterministic choice gives concurrent logic programming (which uses stream mergers: unnamed, nondeterministic, and concurrent).
Adding ports or cells, respectively, gives message passing or shared state (both are named, nondeterministic, and concurrent).
Nondeterminism is important for real-world interaction (e.g., client/server). Named state
is important for modularity

Started F#

Where to start is the question, and here is a short intro from the best sources I could find:

1. Don Syme’s weblog

He is the creator of F#, and emphasizes the succint and expressiveness of the language.

F# makes three primary contributions to parallel, asynchronous and reactive programming in the context of a VM-based platform such as .NET:

(a) functional programming greatly reduces the amount of explicit mutation used by the programmer for many programming tasks
(b) F# includes a powerful “async” construct for compositional reactive and parallel computations, including both parallel I/O and CPU computations, and
(c) “async” enables the definition and execution of lightweight agents without an adjusted threading model on the virtual machine.

2. Chris Smith’s Programming F# book in 20 minutes Part I and Part II

Notes from the book:

* F# supports functional programming, tells what to do, not how to do.
* F# supports imperative programming

Example:

let functionalSum numbers =
  numbers
  |> Seq.map square
  |> Seq.sum

let imperativeSum numbers=
   let mutable total=0
   for i in numbers do
     let x= square i
     total <- total + x
   total

* F# supports OO programming, you can abstract the code into classes and objects.
* F# is a .NET language with all libraries, Garbage Collector, and CLI.
* Everything is immutable by default, so you can experience side-effect free development.
* F# is statically typed, at compile time you have the type-safe code.
* Take care of:
– the order of the files of your project in your solution explorer, they will be compiled from top to bottom.
– indentations, as there are no curly brackets, the indentation will define the scope.
– also F# is white-space significant, and case-sensitive.

3. An introduction to F# at Channel 9 by Luca Bolognese. Notes from the presentation:

You went to counter, and told that you want a cappucino, and start to tell “Now you grind the coffee, and get the water, warm it. At the same time, prepare the milk, but I want those things go in parallel.”

Three key things he emphasizes:

1. let keyword bind a value to a symbol

let sqr x = x * x

2. Arrow “->”, similar to “=” in C# for assigning value; but it is more specific: it means you are pushing something inside the location in memory, not working with symbols any more.

let addBalance x=
    let balance =0.0
    balance <- balance + x

3. fun: Function/lambda expression as in c#

(fun x->x+3) 7;;

which takes 7 as parameter and returns 10 or

List.map (fun i->i*2) [1..4]

which return [2,4,6,8]

4.Don Campbell’s blog about why he loves F#

5. The F# community, HubsFs

6. F# at Microsoft Research

7. Phil Trelford’s session at EdgeUG talk, with nice F# samples.

Anything I have missed?

VS2010 installation dissappointment

Yesterday I have installed my VS2010 RC, but did not work when I try to set F# as default settings, and try to open a new project [any project unfortunately]
The error message is :
“The project file ‘C:\Users\Ebru\AppData\Local\Temp\qxdqjrxq.oco\Temp\Library1.fsproj’ cannot be opened. because its project type (.fsproj) is not supported by this version of the application.
To open it, please use a version that supports this type of project.”

here is my screenshot…

How dissapointing is that I have to install R# Runtime separately…And to fix this you may re-run this exe and repair it.
Then, you may start your F# project.

And

Agree to Agree

Thanks to LondonGeekNightsat Thoughtworks yesterday evening, I had the chance to enjoy Pat Kua and Liv Wild, talking about the “conflicts” happening during the projects, and how to solidify, materialise these soft issues.
They have done a fantastic presentation, and obviously good preparation.
The bits I found quite useful are :
– use a structure before starting conversation:
ORID [1.Objective, 2.Reflective, 3.Interpretive, 4.Decisional]
– Importance of how you give/receive feedback and preparation for this.
– Rituals [having something every week where you can talk anything but work, teas, lunches]
– Doing proper/regular Agile Retrorespectives
[technical and personal agile retrorespectives] and a book suggestion
-Using six thinking hats while doing retrorespectives
-Team disruption, changing members
-Being explicit when you are playing the devil’s advocate.
On my side,
The conflict starts when both side feel sentimental about the subject and can’t put emotions beside. Let’s give example of Andy and Betty working in the same team. Any decision required can instantiate a talk between them. The ultimate goal should be sharing their experiences and enlarging their understanding on the subject.
However, human psychology starts with starting the things “they know”, “they believe”, totally living in their comfort zones. It is quite common that people are coming from different backgrounds; and maybe people like playing “devil’s advocate.”
“Crucial Conversations Tools for talking when stakes are high” was a useful book in this subject. Leaving emotions aside, being able to communicate, and having an agreement while you are keeping the relationship longer…I have realised that I have blogged about this book before, so I reckon it is the time:

Start with your Hearth:
– State what you really want
– State what you don’t want
– Find alternatives and creative solutions

Analyze your stories:
-Question your feelings and stories
– Don’t confuse stories with facts

Get Back to Facts:
-Separate fact from story by focusing on behaviour
-Spot the story by watching for “hot” words

Watch out for three clever stories:
– Victim [it is not my fault]
– Villian [it is all your fault]
– Helpless [nothing else I can do]

Use a structure: [STATE]
-Share your facts
-Tell your story
-Ask for others paths
-Talk tentatively
-Encourage testing

In addition to these, obviously there are personality differences, Belbin roles, and colors of people during normal state and in conflict state, which are all subject to another blog, until then take care!

That’s all folks for today, hope you enjoyed!

Verifying the xml send to webservice

Although there are nice tools, like SoapUI for testing webservices, the hard part I found was verifying the xml send over http. The parameters were sent in correct format, the xml schema verified, but the values are placed as they supposed to be? The list goes on…
Netmom, Network Monitor, available under Administrative Tools, with WireShark solves the problem instantly. Quite easy to use, and the benefit is priceless!

There are just four steps to set up the Netmom, and Wireshark is good at displaying the result.

Step1:Open Menu->Capture->Addresses->Add
Put IP Address in Name and Address, then OK e.g. destination = 192.168.241.10

Step2:Open Menu->Capture -> Filter
i) Highlight Address Pairs
ii) Address -> Add
iii) Select:
* MCJS-WKS004 172.23.63.154 on left hand side i.e. your own machine NOT the 127.0.0.1 one
* Choose the destination IP Address in right hand column
iv) If no traffic is captured – then choose ANY as destination

Step 3: Menu-> Capture -> Start and you can run your test now.

Step 4: Open the saved file with Wireshark.