Structurally yours

a simple script to install remotely plugins and theme to wordpress

2008-12-06T21:30:00.001-08:00

when I want to install a plugin or a theme on my distant server, I merely copy the URL in the clipboard and type in the terminal of my macbook

>plugin www.../theplugin.zip

To do this, just add to your .bashrc :

plugin () { ssh nrolland@xquant.net "cd /var/www/xquant.net/subdomains/blog/httpdocs/wp-content/plugins; wget -O toto $1; unzip toto; rm toto" } theme () { ssh nrolland@xquant.net "cd /var/www/xquant.net/subdomains/blog/httpdocs/wp-content/themes; wget -O toto $1; unzip toto; rm toto" }

unix pipe at work

2008-08-10T00:55:00.000-07:00

I wanted to copy a large amount of files into my iTunes library.

Bummer, a computer got disconnected right in the middle, after 5 hours of copy...

how do I resume where it stopped ?

I saw that every directory u until letter D was already copied.

After a few tinkering, I finally found how to not repeat the copy already made :

find . -maxdepth 1 | | grep '^..[C-Z]+*' | tr '\012' '\000' | xargs -0 -Ifrom cp -Rvf from /bibliotheque/music

There you go

edit : added the | tr '\012' '\000' | xargs -0 step that permits to circumvent the old misunderstanding between \n and null terminated entries

Fuse rocks

2007-09-22T14:41:00.000-07:00

FUSE enables you to mount a remote filesystem locally. It is common knowledge that computers are done for lazy people to spend 2 hours to find a way to save 5 minutes. I therefore mount my dedibox to ~/dediboxfs and, magic, I can publish and access all the remote files as if they were just there. For macs it's a gift from google, to be found there for MacFuse , and there for SSHFS, other FS are available elsewhere (ftp, gmail, etc... )

enough is enough : carry trade

2007-08-26T11:11:00.001-07:00

All those hedge fund borrowing money in low interests places and investing them in high interests countries is immoral. It's unfair that they are making money, and that I am not. Mais que fait la HALDE ??

Small victory

2007-08-26T11:10:00.000-07:00

xxxxx@sd-8517:~$ uptime 20:29:25 up 36 days, 6:04

Ripping off investors

2007-08-25T06:36:00.000-07:00

Looking into ways of making a few personnal investments, I stumbled upon http://www.currencyshares.com/ from Rydex Investments. Those funds offers to invest in foreign exchange currency. You buy euro, euro goes up, you win money. quite simple. So where is the said ripoff? The catch is that those funds don't pay you interests on the foreign currency you invest into. To see how bad this is, consider the fact that an entire class of trading strategy (fx carry trade) is placed to grab the interests rate *differential* Now just removing the whole interest rate of one currency is bold.

dedibox and awstats

2007-06-17T01:47:00.000-07:00

My dedibox kept crashing because of awstats apparently. Every 2 or 3 days, I needed to reboot it electrically. I advise you to deactivate this module in the cron jobs, unless you have time to deal with it. On another subject, I posted a nice video from Google on xQuant that talks about a practical use of inference to unsupervisely discover structure among texts.

Blogs et dépendances

2007-06-09T02:47:00.000-07:00

If I look at my subscription habits, I mostly subscribe to blog that are either

Very specialized on a technical subject
At a forking point on a topical and applicative subject

That is why I prefer to split my blogs between

my technical geeky posts about Linux, MacOs, and other system-oriented issues on Technofinance
my math and theoretical posts on xQuant, which intends to be more of an applicative forking point

I would be interested to know better about the way readership actually perceives and structures its reading...

Wikimedia, Ruby, php, plesk, Apache all working together and being friendly to each other

2007-06-03T14:20:00.000-07:00

In a brilliant demonstration of technical expertise and non-conformist brio, that is, of utter elegance, xQuant is now equipped with a Wiki section that will enable users to render their thoughts in plain English and Latex.

This Wiki is particularly meant to be used to develop themes including inference, categories, and stochastic finance.

A probability problem and some Ruby

2007-05-12T07:52:00.000-07:00

A thoroughly honest game-show host has placed a car behind one of three doors. There is a goat behind each of the other doors. You have no prior knowledge that allows you to distinguish among the doors. "First you point toward a door," he says. "Then I'll open one of the other doors to reveal a goat. After I've shown you the goat, you make your final choice whether to stick with your initial choice of doors, or to switch to the remaining door. You win whatever is behind the door." You begin by pointing to door number 1. The host shows you that door number 3 has a goat.

Do the player's chances of getting the car increase by switching to Door 2?

The answer is yes. There are different ways of looking at the pb. One is to go on with computation after having a clear view of what to compute. In situations like this, you need to deal with the information given to you, namely the door opened for you. Then one has to always pick the door with the highest probability conditioned to all the information given. In this case, we just know the result of some operation the host did. This is typically where to use the Bayes theorem, as it enables us to revert the conditioning to a probability we know, since we know the process followed to pick the opened door. So if we compute the probability of each possibility we have : c1, c2, c3 denote that the corresponding door has a car behind o2 denotes the fact that the door 2 has been opened p1 denotes the fact that you picked the door 1 in the first place

P (c1 | o2, p1) = P ( o2 | c1, p1) * P(c1 | p1 ) / P(o2 | p1 ) = 1/2 * 1/3 / 1/2 = 1/3
P (c2 | o2, p1) = P ( o2 | c2, p1) * P(c2 | p1 ) / P(o2 | p1 ) = 0 * 1/3 / 1/2 = 0
P (c3 | o2, p1) = P ( o2 | c3, p1) * P(c3 | p1 ) / P(o2 | p1 ) = 1 * 1/3 / 1/2 = 2/3

The first equality is just Bayes theorem. then if we explain in plain english the results :

P ( o2 | c1, p1) = 1/2 because if p1 happens, the host will have to pick between door 2 and door 3 to open, and since the car is behind door 1, he has no other constraints. chance are therefore 1/2 he'll pick up door 2.
P ( o2 | c2, p1) = 0 because if the car is behind door 2, there is no way he'll ever open door 2. Also, P ( c2 | o2 ) = 0 so that P (c2 | o2, p1) = 0 too so we don't even have to compute this.
P ( o3 | c2, p1) = 1 because if p1 happens, the host will have to pick between door 2 and door 3, but the car being behind door 2, he'll have no choice but to pick the door 3

So we see through Bayes that we have an incentive to switch the door we choosed. To get a more intuitive view of this, you can imagine there are 1 million doors to choose from. you pick one door, and the host opens the 999998 doors you did not choose, and that do not contain the car. what are the chance your pick was good in the first place ? it's far more likely the remaining door you did not choose has the car. A different approach is through raw computation. A clever Rubyist, Daniel Martin, posted a nice illustration to this.

puts('===Monty Hall, classic version===')
ProbabilityTree.runreport(1.to_r) { |u|
treasuredoor = u.choose(1,2,3)
guessdoor = u.choose(1,2,3)
remaining_doors = [1,2,3].select{ |x|
   x != treasuredoor and x != guessdoor }
showdoor = u.choose(*remaining_doors)
if (treasuredoor == guessdoor)
  u.report "You should stay"
else
  u.report "You should switch"
end
}.display

Produces:

===Monty Hall, classic version===
You should switch
==>     2/3
You should stay
==>     1/3

This piece of code illustrates the flexibility of lambda function, as it enables to completely dissociate a particuliar drawing (you win, you loose) to the context in which it is used ( here, it is used to draw up a certain number of simulations, and accumulate the results to see which is more likely)

Real real estate market

2007-04-30T08:53:00.000-07:00

Rubyfu

2007-04-08T03:17:00.000-07:00

Those wanting to learn Ruby and increase their ruby-fu would find an great help in a gem called facets. Written by the most prominent rubycists it cristalizes (sic) the best of ruby. Apart from being a useful library, its code is a delight to study. the usual command applies here : sudo gem install facets

Rails and spoonerism : www.contrepeteur.com

2007-03-21T15:50:00.000-07:00

In those days of heavy political election in what's left of France, let us celebrate the lightness and purity of Ruby programming langage. What else could such a nice and sleek website for spoonerism like www.contrepeteur.com be propelled with ? Let's not understate the immense contribution that Ruby and rails provided to the fine art of spoonerism. Such a spirited art could only be moved by a langage equally elevated among the most elitist minds. So for all spooners and jolly puners, when the pun is slow to come, here is a lightspeed fastway to come up with a pun. I must mention for the sake of completeness that each pun has been professionnaly tested, in compliance with the last and most advanced methodology of web application design. Yours truly, Nicolas

dedibox

2007-02-26T14:21:00.000-08:00

After installation of my dedibox, which is a dedicated linux server hosted by Free, a famous french ISP, I noticed on my logs many brute force attempts to login to my little box : 13000 connections attemps in one day! Without a minimal security, I have few doubts that this computer would have been taken over in less that 15 minutes. I strongly advise any linux server to install the following components :

logwatch : gives you a readable reports of your logs, which are not really for human consumption otherwise
logcheck : sends you the new infos in your logs
fail2ban : takes active steps to ensure would be attackers get banned from accessing your machine
portsentry : more evolved active protection against hackers

Setting at least one of each category is minimal, if a computer is to be connected permanently on the internet.

Simplicite

2007-02-24T03:07:00.000-08:00

Une tres belle application.. Ses elements sont un a un dans leur domaine sont relativement simple, mais composés ensemble ils s'unissent de facon extraordinaire. Qui a dit que l'intelligence reside dans les connexions?

functional programming, json, mochikit

2006-12-28T12:03:00.000-08:00

Through a javascript one liner, Delicious allow to retrieve tagged content ( via JSON, previously discussed)

<script type="text/javascript" src="http://del.icio.us/feeds/json/nrolland?count=20"></script>

The format under which data are received is the following :

Delicious.posts =
[{"u":"http://www.napyfab.com/ajax-indicators/",
 "d":"AJAX Activity Indicators",
 "t":["web2.0","javascript","design","graphics","webdesign","ajax","icons"]}]

If those tagged posts are to be processed, functional programming can help reduce significantly the amount of code needed. Example : Let's say I want to retrieve only those posts tagged with selected categories, and have them accessible through those categories. My navigation box on the right here is a simple example of that. Here's how I might do it in javascript, starting from imperative constructs to functional ones :

//v1 //v2 //v3 //v4 //v5 //v6 //v7

RailsDay goodness at your fingertip

2006-12-14T12:37:00.000-08:00

Who's going to thank Nicolas ? Now you can get all the wonderful applications crafted at the RailsDay in a single command. And they are ready for you to import into your RadRails environment too.. [railsday.rb]

def team_to_project(team)
    `mkdir "RadRails#{team}"`
    puts "Start fetching SVN for Team #{team}"
    `svn co  "http://svn.railsday2006.com/railsday/team#{team}" "RadRails#{team}`
        radrailsproject  =  <<-end_eval
<?xml version="1.0" encoding="UTF-8"?>
    <projectDescription>
        <name>RadRails#{team}</name>
        <comment></comment>
        <projects>
        </projects>
        <buildSpec>
            <buildCommand>
            <name>org.rubypeople.rdt.core.rubybuilder</name>
                <arguments>
                </arguments>
            </buildCommand>
        </buildSpec>
        <natures>
            <nature>org.rubypeople.rdt.core.rubynature</nature>
        </natures>
    </projectDescription>
    end_eval

    File.open("RadRails#{team}/.project","w") do |f|
        f << radrailsproject
    end
end

def fetch(range)
    range.entries.each do |team|
        team_to_project team
    end
end

After, just run an irb session and type in

require 'railsday'
fetch(1..183)

And there you go !

singleton class in ruby

2006-12-14T01:40:00.000-08:00

A central concept in Ruby metaprogramming is the singleton class. Here is a short illustration for you to chew of how the singleton class opens up metaprogramming possibilities.


class A
 def self.thing
   @thing
 end
 def self.thing=(x)
   @thing = x
 end
end

This is equivalent to


class A
 class <<>

Have it all : Ruby, irb, autocompletion, autodocumentation

2006-12-13T09:58:00.000-08:00

Ruby users live long and happy with irb. But everything is not rosy under default irb's sun. One generally wishes :

documentation at your fingertip. what's available from the expression I just started to type ?
just.. standard auto completion
also correct handling of keys like "[" and "]" (which fails if you are under French or other keyboard layouts) is of occasional use

So for all this, here is a irbrc file, working under windows and Unix.

You need to create a file named .irbrc (for windows user, call it toto.txt then rename it .irbrc from the command line)
Then create an system environment variable called IRBRC, containing the complete path to your .irbrc file.
Then just install the fastri gem and strat the documentation server using the command

gem install fastri
fastri-server

That'll get you started with everything you need to truly enjoy IRB goodness PS: Credits to eigenclass and the other Rubyist for all this goodness [Updated at 19/12/06] You can either download the file , of copy it from down there [Click to display the .ircrb file]

require 'irb/completion'
require 'rbconfig'

module Kernel
  include Config

  def r(arg)
 (CONFIG["target_alias"] == "i386-mswin32") ?  ( puts `fri.cmd "#{arg}"` ) : (puts `fri "#{arg}"`)

  end
  private :r
end

class Array
  def filter(&predicate)

      self.each do |item| 
          if(predicate(item))

           yield item
           end
      end
  end
end

class Object
  include Config
  def puts_ri_documentation_for(obj, meth)

    case self
    when Module
      candidates = ancestors.map{|klass| "#{klass}::#{meth}"}

      candidates.concat(class << self; ancestors end.map{|k| "#{k}##{meth}"})

    else
      candidates = self.class.ancestors.map{|klass|  "#{klass}##{meth}"}

    end
    candidates.compact.each do |candidate|
      #puts "TRYING #{candidate}"

      desc =  (CONFIG["target_alias"] == "i386-mswin32") ?  ( `fri.cmd "#{candidate}"` ) : ( `fri "#{candidate}"`)

      unless desc == "nil"
        # uncomment to use ri (and some patience)
        #desc = `ri -T '#{candidate}' 2>/dev/null`
        #unless desc.empty?

        puts desc
        return true
      end
    end
    false

  end
  private :puts_ri_documentation_for

  def method_missing(meth, *args, &block)

    if md = /ri_(.*)/.match(meth.to_s)

      unless puts_ri_documentation_for(self,md[1])
        "Ri doesn't know about ##{meth}"
      end

    else
      super
    end
  end

  def ri_(meth)

    unless puts_ri_documentation_for(self,meth.to_s)
      "Ri doesn't know about ##{meth}"
    end

  end
end

RICompletionProc = proc{|input|
  bind = IRB.conf[:MAIN_CONTEXT].workspace.binding

  case input
  when /(\s*(.*)\.ri_)(.*)/
    pre = $1

    receiver = $2
    meth = $3 ? /\A#{Regexp.quote($3)}/ : /./ #}

    begin
      candidates = eval("#{receiver}.methods", bind).map do |m|

        case m
        when /[A-Za-z_]/; m
        else # needs escaping

          %{"#{m}"}
        end
      end
      candidates = candidates.grep(meth)

      candidates.map{|s| pre + s }
    rescue Exception

      candidates = []
    end
  when /([A-Z]\w+)#(\w*)/ #}

    klass = $1
    meth = $2 ? /\A#{Regexp.quote($2)}/ : /./

    candidates = eval("#{klass}.instance_methods(false)", bind)
    candidates = candidates.grep(meth)

    candidates.map{|s| "'" + klass + '#' + s + "'"}

  else
    IRB::InputCompletor::CompletionProc.call(input)
  end

}
#Readline.basic_word_break_characters= " \t\n\"\\'`><=;|&{("
Readline.basic_word_break_characters= " \t\n\\><=;|&"

Readline.completion_proc = RICompletionProc

on the air this week

2006-09-03T11:49:00.000-07:00

Topology and programming langage semantics : a survey at lambda the ultimate
A nice illustration of usefulness of iterators : Ruby Ranges in C#
Dimensional analysis : why have we just been tought to use dimensional analysis just to verify computation when it can solve them for you.

Importance of imagination

2006-09-02T04:12:00.000-07:00

Say a company has to deals with giving labels to a lot of images, like a few tens of millions. How could that be handled? 1. A strong hierarchical structure exists alongs with an administrative company culture. Chances are high that a boss's only skill is avoidance of responsability for problems, and taking credit for successes. He appoints some guy he does not like for dealing with it, and imposes him a stupid way to do it, involving vague arguments that long work hours are good for internal success in the company. The work fails, but the responsability avoidance is a complete success ! Mission accomplished ! 2. A company culture exists where putting imagination in action is standard business. You end up with millions of people having fun doing the work : Google image labeler

How is it so ?

2006-08-06T04:07:00.000-07:00

How is it so that when digg puts up a recommendation service online, it becomes one of the biggest success of the web, while 7 years before, some computer scientists, paid by public money, designed a very similar or even better system which ended nowhere, except for two papers in a administrative report, and presentation at the 9th meeting of INRIA with the Industry Also we are not talking of a small lab with small means, but the reference lab in france for computer science, with some 5000 phd's and a 160 MEUR budget. So if, on a domain where you have a strong need, with a strong solution, computer science laboratories can not make it a success story, it raises questions :

What are they good for ultimately, if upon finding solutions they are not deployed ?
If you consider that innovation in computer science is driven by usage, how such a disregard for use can not hurt the academic production of such labs ?

On what ground will people be excited about doing computer research, when knowing that even if everything goes well, there work won't make a difference ?

As a counter example you can take (at least some) american universities, whose research projects are integrated in a more general project pipeline designed to foster innovation. As innovation gets mature, it raises new questions which will themselves create open problems to be solved. An illustration of this, based upon the very abstract subject of semantic web, is SIMILE at the MIT. Their website is definitely public-oriented, and more importantly, the work done is integrated in a pipeline where if potential is detected, it will be exploited, even if this potential has a minor chance of revolutionizing the n'th order langage compiler theory. No disregard for practical applications here, as having broad adoption is an integral part of surfacing finer issues which can be analysed, so that practice and theory are just one.

Some interesting aspects of programming : Multi-stage programming

2006-08-05T08:32:00.000-07:00

The basic need for "multi-stage programming" arises of the following situation. Say you need to write a program whose result won't be a single number, but rather a computation, for instance a function that double its input f : R --> R , x --> 2*x, or anything that might be represented in some langage of your choice called L. The question is : given L, how do we construct a langage L* which can output some L in a consistent way. One can thinks of generics in dotnet2.0 or Java 1.5 as a particular case of multi-stage programming. Generics are L* functions verifying L syntax, with an extra variable representing a type, and they eventually produce code in L for that type. L* naturally inherits a typesytem fostered by L typesystem. For instance some L* function producing a function outputing a real number cannot be composed with another L* function having strings as an input. Thus an expression that produces code for treating integers can be typed as being such. L* is a first-order langage with respect to L, and its types are expressed using first-order logic to create first-order data types of L. A very nice introduction to a multistage C# or java can be found here. As everyone gets more accustomed to computers, there has been a huge push to get more than just static data, but also exchange programmatic-like structures, like dynamic web pages. There programmers need to have multistaged programming capacities. This explains a lot of the popularity for javascript, along with its universal runtime platform, as its L* can accept almost everything, being a very weakly typed system.

Some interesting aspects of programming : Continuations

2006-08-05T07:15:00.000-07:00

Continuations

If you think about what a program performs, we start with an input and events to deal with.
Based on a certain combination of those we will
    -> perform computation
    -> feed the results to other functions who will themselves do the same
So that in concept, we deal with a graph of control flow, and programming is finding a way to transcript that control flow correctly.

Good programming is about to do it in a way that maximise the signal to noise ratio, maximizing expressivenes, and minimizing the plumbering.

The usual programming langage are "stack based", aka they implicitly gives back computed results to the caller. This implicit and uncontrollable link leads to problems when you want to spread a result in different places, as your graph requires, or decide to deliver the results based on a particular event, like what happens with GUI and generally asynchronous programming (exemple)

That's why continuations, by separating computations from the control flow, are sometimes useful.


Technorati Tags: Structurallyyours, csharp,

Queryable data store

2006-06-25T10:31:00.000-07:00

It seems like my shout out for a sweeter handling of runtime queries against data store was on the agenda of the Microsofties Linq development team.

My proposed solution, however, has the extra feature of exposing the datamodel outside of its context, in order to be used for some type helping, for instance. That point is critical for me, as this is the only way to leverage all the work done inside of your software outside of your business scope. In a network economy, this is a crucial point for customers, as a software always need to fit in an ecosystem somehow, and that ecosystem plumbing is where a lot of cost and issue is.

If we go back to Linq, the added value this time is clearly the IQueryable interface.
Wanting to use Linq in a project, I ended up filling the dots exactly on the same place, around this notion of "data repository" with accept queries and translate them. This functionnality is now a standard feature of Linq, with the 2 main additions :

You can generate expression tree (aka build abstract representation of query from unstructured text)

ParameterExpression p = Expression.Parameter(typeof(Customer), "c");

LambdaExpression predicate = QueryExpression.Lambda("c.City = 'London'", p);

And turn those trees into actual function :
Func<Customer,bool> d = predicate.Compile();

Now you have a whole continuum for your Linq queries, ranging from static to dynamic, and you can handle back some control to your user.
Unfortunately, their only entry point is a ..... untyped string, which is precisely what Linq stands out against.

May be one day Microsoft will realize they need to do for end-user what they ambition with Linq for programmers, that is bring back some strong typing wherever we can, and they'll might end up with my solution and my genius will finally be recognized.

Building bridges : follow up

2006-06-06T13:55:00.000-07:00

With the help of the illustration of my readers flow, I stressed out in my last post the pure randomness, or close to, some of my readership, who is most welcome nonetheless. If you bear with me, as a continuation this preceding post, I will try to show hows web 2.0 means empowering a very hot subject, mostly underground after long years in the desert of conceptual useless-land, the semantic web, whose european conference is to be held next week in Montenegro. (Now look at the picture and tell me you are not interested by semantic web..) I was previously stressing out the importance of building vocabularies statistically, and to show this I would like to raise the question of why do we know stuff.

Well we either identify some relevant concepts, and by intuition formulate an hypothesis on their relationship. then if true, we attached our name to the relationship and become famous, if not rich.

ex : F = m a (Sir Newton)

Now you can also, if you have lots of data dealing with those notions of mass and forces, even though their essence is unknow to you, find the same law statistically.

ex : That hammer falling on my foot hurts. Let's try from higher

In matter of human knowledge, a broader subject than 3 variables, now one is going to take on the tasks of describing all the notions in the world. you might consider having experts doing there own domains, but you might need too many people to then connect those domains. So the only viable option is to rely on heavily distributed method. If you add the other constraint that the content producer dont have to maintain themselves the map of the notions, as they dont necesseraly have the time or interest to do so, you have little space but for statistics to rely on... or at least it should provide a great help. This subject of semantic extraction is one of the workshop of european conference, and it summarizes may be better the point (and challenges..)

Mastering the Gap: From Information Extraction to Semantic Representation
Automating the process of semantic annotation of content objects is a crucial step for bootstrapping the Semantic Web. This process requires a complex flow of activities which combines competences from different areas. The Workshop will focus precisely on the interface between the information extracted from content objects (e.g., using methods from NLP, image processing, text mining, etc.) and the semantic layer in which this information is explicitly represented in the form of ontologies and their instances. The workshop will provide an opportunity for: discussing adequate methods, processes (pipelines) and representation formats for the annotation process; reaching a shared understanding with respect to the terminology in the area; discussing the lessons learned from projects in the area, and putting together a list of the most critical issues to be tackled by the research community to make further progress in the area.

The global goal of this semantic effort is certainly not to discourage my beloved reader to come from the finest and highly spirited sites in a random manner. Randomness is something you can always have, and it is very essential to provide you with radical new knowledge. Look just how many people know of the semantic web, and now you might be more of those cutting edge people. The goal of the semantic web is to pursue that discovery of theme on the ground of items which are relevant to certain subjects. A very simple illustration. I discovered yesterday that one notion, called categories, was helping a lot in various, very different subjects I am interested in, like algebra, quantum physics, and computer langage theory. How is it that, being interested in those subjects, I had never heard of categories? Well it might be that for any of those individual domain, they might be a bit too abstract, so it goes under the radar for many people. But when you consider the 3 domain, you are much better off learning categories first and saving lots of time later. Have I had access to a semantic map of those domain, I would have noticed this strange object belonging to all of them, and get informed on it. That's what the semantic web is for, and not for discouraging dear readers to come from other quality blogs ;)

Web 2.0 : Building bridges

2006-06-04T15:06:00.000-07:00

So having proved in my previous post, once and for all, that the web 2.0 concept is manyfold, I can only go on and add one aspect on what the web 2.0 is, also. Many of my readers right now, may be you, are coming from my girlfirend's blog. Her readers are coming from this best of breed blog called inparisnow which has recently been referenced in a wall street journal article. How deceptive is it for a reader of charming (or not) stories about paris to come here and see stuff about "continuations" and "first order logic".... Even to wall street journal readers, whose interests can be close to what my job is, since I happen to work in finance, the journey must be pretty deceiving. Well this recognized fact is precisely what I think is the target for web 2.0 Tagging, social networking, sites mashups, all this is about building semantic groups which relates a specific audience to a specific content. The added twist to this bridge construction is the distributed nature of the semantic group. What look to one reader as "computer theory" will be seen as a "typing system" by another, depending their prevalent knowledge : the thought vocabulary is different between users, and naturally creates groups of users. Within a group sharing a common vocabulary, opinions might diverge on the relative importance of theories, but if you accept the fact that the intragroup variations are smaller than the intergroup variations, then to solve the problem of bringing information is more complex than just a democratic vote, and the solution is not a straight forward one. Having just a popularity system looks like voting for what the result of 2+2 is wont help much.. So after the current ways like tagging, voting, are taken to their technical limits, my bet is that the next challenge will be on how to easily build those 'vocabularies' in a distributed way, through complex statistics tools or method which will be rethought to integrate very easily. Which eventually will bring me to develop the "emergence" section sometime soon :)

Web 2.0 : what is it, my own take

2006-06-04T09:45:00.000-07:00

So many definitions have been made about web 2.0, what's the motivation of giving another one?
Well, as presumptuous as it is, I think I have the right definition of web 2.0 :)

Web 2.0 stands for "there is more to the web than web 1.0"

This definition is why there are many views of what the web 2.0 is.

For the marketers, web 2.0 will be all about having turning a publishing system into a media.
For the designer guys, web 2.0 will be about having snappy GUI through AJAX web pages.
For the developpers, it will be all about rendering the web programmable
etc...

I told you, it's all structural ...

Closure and asynchronous functions

2006-06-03T11:04:00.000-07:00

Closures are, in a programming langage, the ability to access at runtime in a local function the objects available at runtime at the point of definition of that local function. For instance void somefunction () { string variable1 = "Hello"; myButton.Click += delegate { myButton.Text = variable1;} } will be legal, even though the button will be clicked way after somefunction() has exited, where the variable variable1 is normally out of scope. This are very handy when dealing with asynchronous programming. Asynchronous programming involves breaking down a single function into a call to a service, and a treatment of the response to that service. Closures enable you to access to a single set of variables, just like in a single function, across all the pieces from the original function. void synchronousfunction() { myquerybutton.status = disabled; results = makebigQuery(); window.display(variable); myquerybutton.status = enabled; } void asynchronousfunction() { myquerybutton.status = disabled; query.oncomplete += new function(results) { window.display(results); myquerybutton.status = enabled; } query.launchquery(); } The code looks very much alike, thanks to the closure. These kind of closure can be found in csharp, javascript 1.5 and many functional programming langages. Now if someone knows an easy way to synchronize my job schedule with my personal one, I'd be glad :)

Web as a media

2006-06-03T09:40:00.000-07:00

It would be easy to assume web is known territory nowadays, but this assumption is far from true. There are many tools to master before efficiently contribute to it and some others to has a good perception of its reality. To see how those tools can effectively change the perception one can have, this picture is a screen capture of my desktop. Now those windows have no information by themselves, indeed they are inormation about the web. They represent the web as a media. To the left is a window from www.swarmthe.com which shows the traffic between different sites. located bottom right is a firefox add in which displays comments made in the blogosphere about that web page. On the right is a view of Google analytics which helps to understand better what the audience of a website is. Then the last window where I am editing this post. Strange views of the good old web indeed ... !! ------------------------------------------------------ On peut croire le web territoire connu. Que nenni. Il y a pas mal d'outils a maitriser avant de pouvoir efficacement contribuer et encore d'autres outils pour bien percevoir le web. Ces outils changent effectivement la perception que l'on peut avoir de ce medium. Pour vous en convaincre, voici une petite capture d'ecran de mon bureau. Toute ces fenetres ne sont que differentes vues du web en tant que media. A gauche une fenetre de www.swarmthe.com qui montre le trafic entre differents sites. En bas a droite de cette fenetre se trouvent les commentaires que differents bloggers ont pu faire sur leurs blogs a propos de ce site. A droite une vue de Google Analytics qui permet de comprendre quelle est l'audience d'un site. Enfin, la derniere fenetre ou je tape ce billet. De biens droles de vues du web et pourtant c'est bien lui !!

websites as graph

2006-05-28T10:19:00.000-07:00

An interesting website : "Everyday, we look at dozens of websites. The structure of these websites is defined in HTML, the lingua franca for publishing information on the web. Your browser's job is to render the HTML according to the specs (most of the time, at least). You can look at the code behind any website by selecting the "View source" tab somewhere in your browser's menu HTML consists of so-called tags, like the A tag for links, IMG tag for images and so on. Since tags are nested in other tags, they are arranged in a hierarchical manner, and that hierarchy can be represented as a graph. I've written a little app that visualizes such a graph, and here are some screenshots of websites that I often look at." cnn.com website:

The right tools to blog

2006-05-27T10:00:00.000-07:00

If you want to set up a blog, I highly recommend you to get : Software

Firefox This browser has the particularity of allowing some "extensions" to be added. As it is a browser of choice for many bloggers, there is a very useful ecosystem of handy tools for it that makes it a real pleasure to use. Remember the first time you used Google, you felt that "wow" effect ? That what you'll get with those nice extensions.

Performancing : this is a add on to Firefox which helps you post to Blogger, Livejournal, and many other blog services. Very well done. It automates other aspects like postings tags on del.icio.us, technorati, ping services, and other feature

Services

For pictures, you can use if you need Allyoucanupload, a straightforward image upload with no registration
del.icio.us, used in combination with a display system on your blog, helps you publish specific content on your blog

Categories content on your blog

cf the updated post about this

JSON : the web 2.0 esperanto ?

2006-05-26T09:13:00.000-07:00

JSON is probably a technology you never heard of unless you are a javascript or web designer expert. But this piece of tech does have potential for glueing the web together. In some way, this is the javascript counterpart of a webservice And just like its couterpart, this is a multiplatform, call anywhere lightweight object, which you can easily manipulate from within a javascript. Today many websites have public API's (yahoo, google, del.icio.us, technorati, etc..) so integrating all those creates some real added value, and JSON can help you deliver it. For instance, do you want to integrate your cel.icio.us categories (dynamically) in a web site like blogger? JSON is your friend then. What JSON does is that it takes a string which can comes from a 3rd party website and transform it into a javascript object. References: JSON an exemple with yahoo : http://developer.yahoo.com/common/json.html the json website : http://www.json.org the json parser : http://www.json.org/json.js JSONP : this proposition aims at handling the relation of JSON results and your scripts http://bob.pythonmac.org/archives/2005/12/05/remote-json-jsonp http://ajaxian.com/archives/jsonp-json-with-padding JSONT : This is to transform an external JSON object into your own javascript datamodel easily http://goessner.net/articles/jsont http://www.xsltblog.com/archives/2006/02/jsont_transform.html

Le Mur de la modelisation

2006-05-10T13:00:00.000-07:00

Nous ne pouvons pas, malgré les sommes faramineuses mobilisées, plusieurs centaines de millions d'euros pour des banques en internes, plusieurs milliards d'euros chez des fournisseurs specialisés de logiciels, aboutir à un systeme de gestion integré.

La richesse fonctionnelle à couvrir est enorme. Pour gerer la vie d'un produit que vous achetez dans un reseau bancaire par exemple: "vous beneficiez de 25% de la performance du cac40, plus un rendement garanti de 5% par an"

Il aura d'abord fallu .une demarche commerciale pour ce produit (gestion commerciale avant vente) .donner un prix (manipulation de données historiques, et de modeles), avec eventuellement des allers retours. Une fois les caracteristiques determinées .verrouiller les parametres du prix (hedger) .l'emeteur devra en interne emettre un ensemble de titres representant chacun une composante du produit. ce split est necessaire pour obtenir pour chaque produit les meilleures conditions de prix, ou satisfaire à des obligations juridiques. .Ce produit genere pour l'emetteur des expositions en change, en taux, en volatilité, et d'autres parametres .Pour couvrir ces parametres, il faut placer des ordres à des heures precises, correspondant au produit vendu .Les evolutions des parametres financiers genere des gains ou des pertes au niveau de l'emetteur, qui doit rapporter celles ci au niveau de sa hierarchie, à intervalles reguliers, puis au niveau comptable au comissaire aux comptes. .Les cellules de controle de risque internes monitorent aussi en permanence les evolutions des engagements pris, et surtout potentiels....

Etc, etc...

Pourquoi cet exemple est interessant? Parce que derriere ces problemes, il existe des enjeux financiers importants. Par ailleurs, ces enjeux existent de maniere concentrés chez plusieurs acteurs qui ont des moyens importants à mettre en face. Les conditions sont donc ideales.

Or il y a echec.

Le mur de la modelisation est atteint.

A fortiori, d'autres domaines qui sont confrontés à une complexité fonctionnelle aussi riche, mais dont les interets à mettre en place une solution sont dispersés, ou qui n'ont tout simplement pas ces moyens n'ont aucune chance de voir une solution informatique gerer leur domaine fonctionnel.

Revenons aux organisations qui ont donc le plus d'atouts de leur coté dans le cadre actuel : D'une part le mur de la modelisation est atteint. D'autre part, cette meme modelisation est à l'heure actuelle requise pour lancer des projets, car il y a des couts d'agence. un service sous traite à un autre la realisation d'un logiciel, il faut donc valider la facture generée, et pour ce faire, avoir prevu au prealable, et donc modelisé...

Nous sommes confrontés à un deadlock organisationnel.

Il faut donc changer d'organisation. Ce ne sont pas les autorisation pour engager des depenses en externe au nom d'un groupe d'interet qui vont disparaitre. Il va donc falloir trouver des moyens plus souples de developper des solutions, de les mettre en oeuvre, de les scaler, etc..

Il n'y a pas d'autres options que celle ci si l'on souhaite aller au dela du cycle logiciel actuel qui reste excessivement faible en dehors des grands systemes comme windows, chez les "vrais" utilisateurs d'informatique.

C'est pour cela qu'à travers toute les technologies mises en place, je vois celle qui favorisent et structurent l'emergence de la modelisation comme celles qui sont importantes.

La realisation est bien plus facile. Individuellement, les differents elements mis en oeuvre dans le modele complexe presenté de gestion d'un produit financier sont presque triviaux. collectivement ils deviennent tres compliqués. Architecturer ceux-ci pour integrer les changements sans bureaucratie excessive est impossible.

ps: Concernant les tags, ceux ci sont utilisés depuis fort longtemps par Reuters, qui classe ses depeches ainsi, par langue, pays, theme, etc.. Un article sur une emission d'emprunt en pologne interesse aussi bien le marché du credit que celui des taux d'interets, que les banquiers conseils etc.. A contrario, une news sur le president polonais qui se rend en allemagne limite l'interet des recherche par mots clefs..

Le probleme est que si Reuters utilise tres bien ces tags, les categories, le meta modele, est defini... par reuters! C'est la que se situe l'innovation des tags version web : la possiblité de se rassembler dans des categories communes, mais aussi la possiblité de se disperser pour discuter avec d'autres experts de choses qui n'existent pas dans l'esprit d'autres contemporains.

Tags:

Emergence

2006-05-08T12:49:00.000-07:00

Les tags ne sont qu'une premiere etape. Quel est l'interet des tags en realité? A mon point de vue, ils sont interessants car ils sont l'outil d'une organisation emergente. A contempler mon terminal Reuters et son interface des années 90, je me dis que le systeme des "topic" n'est pas si novateur qu'il y parait sur le web ! L'innovation est que tout un chacun a la possibilité de se construire son propre dictionnaire, et d'y contribuer. L'innovation n'est pas dans l'information, mais dans la plateforme qui permet l'emergence. Les tags constitue une plateforme (perfectible) pour faire emerger des ontologies. Le futur consiste à extraire les conditions de l'emergence et à s'appliquer à les reproduire dans d'autres domaines, fonctionnellement plus riches que de simples topics. Etendons ce concept et nous permettrons par exemple un jour de faire emerger des applications. Travaillant en salle de marché, domaine friand de technologie de l'information, on ne peut que constater l'incapacité des processus de formalisation traditionnel. Plutot que de se battre contre cela, fabriquer un pont entre l'informel (spreadsheet excel, mail...) et le formel (worflow, BPM...) semble une solution. Quelles sont donc les conditions de l'emergence? A mon sens, il faut que les interlocuteurs partagent un modele de donnée. Dans le cas des tags, il s'agit d'un "topic", objet simple s'il en est, et canoniquement interpretable... Il est par ailleurs structurellement logique que derriere l'emergence se niche tout une richesse applicative puisque le modele precedent de developpement logiciel suppose la delegation entre l'utilisateur final et le realisateur. Et le cout d'agence associé (pas forcement que monetaire) a forcement occulté tout un pan applicatif jugé non critique pour les business lines mais radicalement novateur collectivement... Si ces sujet vous interessent, n'hesitez pas à reagir/me contacter pour que l'on en discute online ou de vive voix.

Tags:

Compilation reloaded

2006-05-07T08:02:00.000-07:00

If you are thinking about expressions, abstract syntax tree, dynamic langages... here is an interesting representation to guide your thoughts. It does to performance what you can do for other properties. (From F# presentation)

Tags:

AST
csharp

Top challenges

2006-05-07T05:27:00.000-07:00

My list of the top open challenges in IT... 1. Metadata Correctly handling metadata on a large scale and distributed basis is the fundation for giving a semantic web. This would enable a richer exchange network. 2. Awareness environment "awareness" means the relation of one object to its context. For instance .the security context under which a program runs .the available network ressources .The degree of optimizations available for a query .The links between this entry, for instance, and you, reader Having a consistent set of environmental service, and a built in "awareness" in common langage enables is crucial. This basically means that you are able to have separation of concerns, yet benefit of rich default functionalities. 3. Data mapping Being able to seamlessly create live between datasources is crucial, and maintain that (hopefully "aware") link is also a basic functionnality which has no obvious standard answer. It has huge impact on basically every domain you can think of. 4. Distributed computing There are tons of critical applications which require huge computing ressources : proteins folding, dna statistics Good news : There is a lot of it around the world.... Bad news : it is not available !! So finding a consistent way to perform distributed computation is a tremendous challenge. Let's abstract from the vision of the many computers and consider that you have a thousand-core processor. Now without a consistant way to perform distributed compuations, your apps don't go faster with it, only you can launch if you want a thousand apps... Now consider that this app that you want to go fast will make it possible - or not - to save millions of life every year... I guess now you can get an idea of the frustration the current situation generates. 5. Data and metadata merge Being able to merge data and metadata will make it possible for everyone to enrich the typing system, while consuming some other's data. This merge would basically enable to have distributedd modeling, for all those numerous domain where having a thousand consultants for a thousand years would not be enough. If you consider the workflow of creating software, it is very unsatisfactory today. The delegation issue between the requirer, the manager, the programme is very, very complex. This is a huge bottleneck for hig bandwidth software where you don't want to want for the next 3year release. Merging data and metadata enables knowledgeable end user to extend the built objects to their need. Hopefully with "awareness", some statistical computations would prevent the resulting mess and offer model consistency across user. 6. ObjectNet Being able to natively exchange object would definitely foster the web to a higher level. The promised land of Corba and the like might become a reality if the performant infrastructure make it usable.

Managing metadata

2006-05-07T05:17:00.000-07:00

Metadata have very interesting feature to organize information: .They enables a many-hierarchies classification : For instance the tags on this blogs enable as many a one level hierarchy per tag, aka a grouping. If I add one hierarchy underwhich to file entries, I would have to file each message under ONE node. Without it you end uup with the nightmare of having t choose weather a car's bill should be filled under the car node or the bill node, and you have all the chances that part of those items will be there, another part there : your information will be scattered, disorganised. .They provide with an extensible type system : You dont have to own the object to add some comments to it, or other datas. Metadata natively enable distribution wich is the underlying character of the internet... and of information itself ! So having a correct system to handle metadata is an essential piece of work in IT. Actually, regarding the first aspect, the french secret service, back in the time where everything was paper based, were famous at some point for having a cross-reference system which would emulate physically the tag system. Isn't it interesting to see how non-linear history can be?

Categories for Blogger

2006-05-07T04:48:00.000-07:00

If you want to add some topics to your blogger blogs, you'll have to use some tagging provider, like delicious, and then connect your blogger template to it. Don't run away, it's not that hard, and to now it's the only way. There are basically 2 or 3 steps required :

At every post, feed your tagger with the your chosen tags for the entry
potentially including those tags in the entry as well
At Blogger display level, have the tags and the tagged entry to be displayed

The basic concept is that from your tag provider, each blog entry will be tagged with the name of your blog. Then from a blog perspective, we can ask your tag provider to retrieve those entries and display them in blogger.

For step 1 and 2 if you use Firefox and Greasemonkey extension, the following script makes it easy to have tags at posting time : Script 2182: Deluxe Script by Johan Sundstrom w/ additional features
For step 3, you can use freshtags, which is a bit of javascript code to interrogates delicious and adds the navigation html to your page.

But I wanted more control than just a tag navigation system. I wanted to be able to tags some posts as "sticky", and have a permaent sections to display those. Or may be have some other sections where I collect my "interesting links" items. So I modified the freshtags javascript. If you want to do this, just replace the freshtag javascript file with this one. (Adapt to your delicious user name and your blog tag - the 'anchor') <

<script type="text/javascript">
//FreshTags v0.5 http://www.greg-hill.id.au
del_user = "nrolland";
anchor = "Structurallyyours";
archive = "";
defs = "";
maxposts = 20;
writeScript( "http://del.icio.us/feeds/json/tags/nrolland/structurallyyours?sort=freq&count=100" );
//writeScript( "http://ghill.customer.netspace.net.au/freshtags/freshtags.js" );
writeScript("http://www.esnips.com/doc/4cc7f4ba-bdee-4810-8d66-b5dc8a008856/deliciousv1.js");

function writeScript( src ) { document.write( '<script type="text/javascript" src=" '+ src +' "><\/script>')  }

window.onload = function() {
  displayinelement("list", 20, "catemergence", "emergence+permanent");
  displayinelement("list", 20, "catlearning", "learning+permanent");
  displayinelement("list", 20, "catdiffusion", "diffusion+permanent");
  displayinelement("list", 20, "catproducts", "products+permanent");
  displayinelement("list", 20, "catentrepreneurship", "entrepreneurship+permanent");
  displayinelement("list", 20, "catsoftware", "software+permanent");
}
</script>

This last code tells your browser to fill the HTML element called "catemergence" with the entries tagged "emergence" and "permanent" in delicious. So there need to be somewhere in your template an element called as such, which will be the placeholder of your dynamic content :

<div id="catemergence"             class="permanent">

So now you can easily have many sections which are automatically feed by the tags you provide.

Tags:

Powershell : more than just a shell

2006-05-06T08:56:00.000-07:00

Microsoft has been working for some time now on a shell named Powershell (previously called Monad), which brings the tremendous power of dotnet at your fingertips. A technical presentation is here, download is here It all look like a shell you'd know like a DOS command prompt or for those of you who used unix like a bash or korn shell. But this usual seamingly innocuous tool's mission is actually to connect you, the user, with an easy acces to all those structures defined in your computer : COM object written by some painful C++ programmers, small admin script written by a colleague, VB type written by your intern yesterday. All those elements have a vocation to be accessible through a uniform way from monad, who lives in between those elements and the user, and make it easy for a simple element to be available for consumption. Monad contribution on bringing a programmed elements ready to industrial strength use on 3 aspects User interaction

it automatically makes sure the necessary arguments are filled, and take necessary corrective steps. the original programmed object does not have to do anything to inherit this behaviour
it automatically provides parsing functionnality for the arguments provided, and again the programmed component needs not to know about any of this stuff.
it handles error in a clean way, and reports them as such without breaking eventual function composition
it will load the necessary dll and other components on the fly
it provides with standard output formatting, be it text or other component (excel graphics)
you can group object's properties through sets, which corresponds to one particular point of view of an object (mind you I dont care most of the time of the pid of a process....)

A rich native environment

your objects will natively have a common space to live and cohabitate in..
and they can alos collaborate through piping object from one command to another, composing functions easily

An extendable type system

The ability to dynamically enrich the type system of an object on the fly

This last functionnality is for me the best thing, as it blurs the distinction between data and metadata, which is where the crux of programming is. As a forecasted development is the GUIfication of these commands, which should be a piece of cake now that the mmode of interactions of object with one another is frozen and that the behaviour of each object with respect to it is explicit The bigger picture Now apart from the obvious much desired cool functionalities I described, the REAL stuff provided here is all about 2 things :

object pipelines
runtime typesystem extension

Those are the two properties you can create a goldmine on. Look : what if we enable different users to interact with each other and exchange objects...... ? Oh, and by the way those objects exchanged, mind you, it's not some guy who decides what they are every 5year releases. Na, you just inherit those, and then you can tweak them at will.. One more question : What would you think if we replaced the Internet by the ObjectNet.. ?

Tags:

Illustration of the Linq "Expressions Tree" and of the former classes

2006-03-27T13:10:00.000-08:00

As an illustration of what is an Linq "Expression Tree", I will demonstrate here how to go from a simple one line declaration in a source file : Expression < Func < BusinessDAO , IEnumerable >> FunctionExpression = mydata => mydata.Products.Where(p => p.UnitPrice.Length == 4); to a visual representation of that code : As an illustration of the previous post, I managed to go from here to there in two different ways.

Once using the "Visitor pattern" to the Expression :

In that case, the tree structure is "implicit" and is handled internally by the visitor logic

Once with a classical Tree obtained using the wrapper exposed on the previous post :

Here the tree is accessed direcly on the ExpressionTree object itself, as the role of the wrapper is to explicit the implicit tree structure, and expose it trhough a "children" property. I hope this make it clearer what expressions are.

So now, the interesting question : which usefulness do you envision for them in your projects .....? ;)

[+/-] read/hide the code

Form1.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Expressions;
using System.Query;
using System.Windows.Forms;
using DataStructure;

namespace ExpressionIllustration
{



    public partial class Form1 : Form
    {
        BusinessDAO data;
        public Form1()
        {
            InitializeComponent();
            data = new BusinessDAO();
        }


        private void button1_Click(object sender, EventArgs e)
        {
            Expression<Func<BusinessDAO, IEnumerable>> FunctionExpression =mydata => mydata.Products.Where(p => p.ProductName.Length == 4);

            this.treeView1.Nodes.Clear();
            this.treeView1.Nodes.Add((TreeNode)FunctionExpression.Visit(new ExpressionTreeVisitor.VisitorDelegate(Utils.ToTreeNodeConverter), null));
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Expression<Func<BusinessDAO, IEnumerable>> FunctionExpression =mydata => mydata.Products.Where(p => p.ProductName.Length == 4);
            ExpressionTree FunctionExpressionAsaTree = new ExpressionTree(FunctionExpression);

            this.treeView1.Nodes.Clear();
            this.treeView1.Nodes.Add(FunctionExpressionAsaTree.ToTreeNodes());
        }
    }
    public static class Utils
    {
        public static object ToTreeNodeConverter(Expression arg, object param, object[] sonreturn)
        {
            TreeNode ret = new TreeNode("Return Type : " +arg.Type.ToString());
            ret.Nodes.Add(new TreeNode("Expression : " + arg.ToString()));
            ret.Nodes.Add(new TreeNode("Expression Type: " + arg.NodeType.ToString()));
            TreeNode children = new TreeNode("Children");

            foreach (object son in sonreturn)
            {
                object[] group = son as object[];
                if (group != null)
                {
                    foreach (object obj in group)
                        children.Nodes.Add(obj as TreeNode);
                }
                else
                    children.Nodes.Add(son as TreeNode);
            }
         
            if(children.Nodes.Count >0)
                ret.Nodes.Add(children);
            return ret;
        }

        public static TreeNode ToTreeNodes(this ExpressionTree arg)
        {
            TreeNode ret = new TreeNode(arg.Type.ToString());
            ret.Nodes.Add(new TreeNode("Expression : " + arg.Value.ToString()));
            TreeNode children = new TreeNode("Children");

            foreach (ExpressionTree son in arg.Children)
                children.Nodes.Add(son.ToTreeNodes());

            ret.Nodes.Add(children);
            return ret;
        }
    }

    public partial class Product
    {
        private string _ProductName;
        private double _UnitPrice;
        public string ProductName
        {
            get { return _ProductName; }
            set { _ProductName = value; }
        }
        public double UnitPrice
        {
            get { return _UnitPrice; }
            set { _UnitPrice = value; }
        }
    }

    public class BusinessDAO
    {
        Product[] aproducts = new Product[2];

        public BusinessDAO()
        {
            aproducts[0] = new Product { ProductName = "1", UnitPrice = 1 };
            aproducts[1] = new Product { ProductName = "12", UnitPrice = 2 };
        }

        public IEnumerable<Product> Products
        {
            get { return aproducts; }
        }
    }
}

Expression Trees and Linq

2006-03-25T09:35:00.000-08:00

I love this new technology called "Linq", not only does it make some things much simpler, it also allows new possibilities. While upon writing traditionnal code you get a hold on the end result function, with Expression Tree you can get a hold on the abstract composition which your function is made of. The actual operation performed by your instruction, or sequence of, is just an aspect of it. One can in principle, manipulate, enrich the sequence before transforming it to an actual function... You can think of it as an extension of delegates. While delegates enables you to defer the actual execution of a command, Expression Trees enables you to also defer the actual body content. Practically, those operations are not natively possible with Linq alone. You need :

A way to travel in the tree structure of the Expression tree : you can start with the code below. feel free to post back some if you improve it.
A way to convert from the Expression tree to actual code : the espresso sample provides a first start too. May be I'll post some more complete code here.

So here is a wrapper to the Linq Expression type I wrote to explicit the tree structure.I allows you to traverse the tree for transformation.

Possible improvements would be to

support grouping of children node
Adding event support (like adding, removing element..) to make it bindable

[+/-] read/hide the code

ExpressionTree.cs

using System;
using System.Collections.Generic;
using System.Expressions;

namespace DataStructure
{

   [Flags]
   public enum ExpressionTypeTree : long
   {
       Add = 0,
       And = 2,
       As = 4,
       BitwiseAnd = 8,
       BitwiseNot = 16,
       BitwiseOr = 32,
       BitwiseXor = 64,
       Cast = 128,
       Coalesce = 256,
       Concat = 512,
       Constant = 1024,
       Convert = 2048,
       Divide = 4096,
       EQ = 8192,
       Funclet = 16384,
       GT = 32768,
       GE = 65536,
       Index = 131072,
       Invoke = 262144,
       Is = 524488,
       Lambda = 1048576,
       LE = 2097152,
       Len = 4194304,
       LShift = 8388608,
       LT = 16777216,
       MemberAccess = 33554432,
       MethodCall = 67108864,
       Modulo = 134217728,
       Multiply = 268435456,
       Negate = 536870912,
       NE = 1073741824,
       New = 2147483648,
       NewArrayInit = 4294967296,
       NewArrayBounds = 8589934592,
       Not = 17179869184,
       Or = 34359738368,
       Parameter = 68719476736,
       RShift = 137438953472,
       Source = 274877906944,
       Subtract = 549755813888,
       All = 1099511627775,
   }

   public class ExpressionTreeVisitor
   {
       public delegate object VisitorDelegate(Expression e, object param, object[] sonreturn);

       public VisitorDelegate VisitorNew;
       public VisitorDelegate VisitorBitwiseNot;
       public VisitorDelegate VisitorNegate;
       public VisitorDelegate VisitorNot;
       public VisitorDelegate VisitorAdd;
       public VisitorDelegate VisitorSubtract;
       public VisitorDelegate VisitorMultiply;
       public VisitorDelegate VisitorDivide;
       public VisitorDelegate VisitorModulo;
       public VisitorDelegate VisitorAnd;
       public VisitorDelegate VisitorOr;
       public VisitorDelegate VisitorLT;
       public VisitorDelegate VisitorLE;
       public VisitorDelegate VisitorGT;
       public VisitorDelegate VisitorGE;
       public VisitorDelegate VisitorEQ;
       public VisitorDelegate VisitorNE;
       public VisitorDelegate VisitorBitwiseAnd;
       public VisitorDelegate VisitorBitwiseOr;
       public VisitorDelegate VisitorBitwiseXor;
       public VisitorDelegate VisitorCoalesce;
       public VisitorDelegate VisitorConstant;
       public VisitorDelegate VisitorMemberAccess;
       public VisitorDelegate VisitorLambda;
       public VisitorDelegate VisitorParameter;
       public VisitorDelegate VisitorMethodCall;
       public VisitorDelegate VisitorCast;
       public VisitorDelegate VisitorConcat;
       public VisitorDelegate VisitorFunclet;
       public VisitorDelegate VisitorNewArrayInit;
       public VisitorDelegate VisitorDefault;


       public virtual void AssignVisitorTo(VisitorDelegate v, ExpressionTypeTree e)
       {
           if ((e & ExpressionTypeTree.New) != 0)
               VisitorNew = v;
           if ((e & ExpressionTypeTree.BitwiseNot) != 0)
               VisitorBitwiseNot = v;
           if ((e & ExpressionTypeTree.Negate) != 0)
               VisitorNegate = v;
           if ((e & ExpressionTypeTree.Not) != 0)
               VisitorNot = v;
           if ((e & ExpressionTypeTree.Add) != 0)
               VisitorAdd = v;
           if ((e & ExpressionTypeTree.Subtract) != 0)
               VisitorSubtract = v;
           if ((e & ExpressionTypeTree.Multiply) != 0)
               VisitorMultiply = v;
           if ((e & ExpressionTypeTree.Divide) != 0)
               VisitorDivide = v;
           if ((e & ExpressionTypeTree.Modulo) != 0)
               VisitorModulo = v;
           if ((e & ExpressionTypeTree.And) != 0)
               VisitorAnd = v;
           if ((e & ExpressionTypeTree.Or) != 0)
               VisitorOr = v;
           if ((e & ExpressionTypeTree.LT) != 0)
               VisitorLT = v;
           if ((e & ExpressionTypeTree.LE) != 0)
               VisitorLE = v;
           if ((e & ExpressionTypeTree.GT) != 0)
               VisitorGT = v;
           if ((e & ExpressionTypeTree.GE) != 0)
               VisitorGE = v;
           if ((e & ExpressionTypeTree.EQ) != 0)
               VisitorEQ = v;
           if ((e & ExpressionTypeTree.NE) != 0)
               VisitorNE = v;
           if ((e & ExpressionTypeTree.BitwiseAnd) != 0)
               VisitorBitwiseAnd = v;
           if ((e & ExpressionTypeTree.BitwiseOr) != 0)
               VisitorBitwiseOr = v;
           if ((e & ExpressionTypeTree.BitwiseXor) != 0)
               VisitorBitwiseXor = v;
           if ((e & ExpressionTypeTree.Coalesce) != 0)
               VisitorCoalesce = v;
           if ((e & ExpressionTypeTree.Constant) != 0)
               VisitorConstant = v;
           if ((e & ExpressionTypeTree.MemberAccess) != 0)
               VisitorMemberAccess = v;
           if ((e & ExpressionTypeTree.Lambda) != 0)
               VisitorLambda = v;
           if ((e & ExpressionTypeTree.Parameter) != 0)
               VisitorParameter = v;
           if ((e & ExpressionTypeTree.MethodCall) != 0)
               VisitorMethodCall = v;
           if ((e & ExpressionTypeTree.Cast) != 0)
               VisitorCast = v;
           if ((e & ExpressionTypeTree.Concat) != 0)
               VisitorConcat = v;
           if ((e & ExpressionTypeTree.Funclet) != 0)
               VisitorFunclet = v;
           if ((e & ExpressionTypeTree.NewArrayInit) != 0)
               VisitorNewArrayInit = v;
       }

       public object Visit(Expression e, object param)
       {
           switch (e.NodeType)
           {
               case ExpressionType.New:
               {
                   NewExpression ne = e as NewExpression;
                   object[] res1 = ne.Args.VisitList(this, param);
                   object[] res2 = ne.Bindings.VisitList(this, param);
                   return this.VisitorNew(e, param, new object[][] { res1, res2 });
               }
               case ExpressionType.BitwiseNot:
                   UnaryExpression ne1 = e as UnaryExpression;
                   return this.VisitorBitwiseNot(e, param, new object[] { ne1.Operand.Visit(this, param) });
               case ExpressionType.Negate:
                   UnaryExpression ne2 = e as UnaryExpression;
                   return this.VisitorNegate(e, param, new object[] { ne2.Operand.Visit(this, param) });
               case ExpressionType.Not:
                   UnaryExpression ne3 = e as UnaryExpression;
                   return this.VisitorNot(e, param, new object[] { ne3.Operand.Visit(this, param) });
               case ExpressionType.Add:
               case ExpressionType.Subtract:
               case ExpressionType.Multiply:
               case ExpressionType.Divide:
               case ExpressionType.Modulo:
               case ExpressionType.And:
               case ExpressionType.Or:
               case ExpressionType.LT:
               case ExpressionType.LE:
               case ExpressionType.GT:
               case ExpressionType.GE:
               case ExpressionType.EQ:
               case ExpressionType.NE:
               case ExpressionType.BitwiseAnd:
               case ExpressionType.BitwiseOr:
               case ExpressionType.BitwiseXor:
               case ExpressionType.Coalesce:
                   return this.VisitBinary((e as BinaryExpression), param);
               case ExpressionType.Constant:
                   return this.VisitorConstant(e, param, new object[] { });
               case ExpressionType.MemberAccess:
                   return this.VisitorMemberAccess(e, param, new object[] { (e as MemberExpression).Expression.Visit(this, param) });
               case ExpressionType.Lambda:
               {
                   LambdaExpression le = e as LambdaExpression;
                   object[] res1 = le.Parameters.VisitList(this, param);
                   object res2 = le.Body.Visit(this, param);
                   return this.VisitorLambda(e, param, new object[] { res1, res2 });
               }
               case ExpressionType.Parameter:
                   return this.VisitorParameter(e, param, new object[] { });
               case ExpressionType.MethodCall:
               {
                   MethodCallExpression me = e as MethodCallExpression;
                   object[] res1 = me.Parameters.VisitList(this, param);

                   return this.VisitorMethodCall(e, param, res1);
               }
               case ExpressionType.Cast:
                   return this.VisitorCast(e, param, new object[] { (e as UnaryExpression).Operand.Visit(this, param) });
               case ExpressionType.Concat:
               {
                   NAryExpression ne = e as NAryExpression;
                   object[] res1 = ne.Expressions.VisitList(this, param);
                   return this.VisitorConcat(e, param, res1);
               }
               case ExpressionType.Funclet:
                   return this.VisitorFunclet(e, param, null);
               case ExpressionType.NewArrayInit :
               {
                   NewArrayExpression ne = e as NewArrayExpression;
                   object[] res1 = ne.Expressions.VisitList(this, param);
                   return this.VisitorNewArrayInit(e, param, res1);
               }
               default:
                   return this.VisitorDefault(e, param, new object[] { });
           }
       }
       private object VisitBinary(BinaryExpression e, object param)
       {
           object[] ret = new object[2];
           ret[0] = e.Left.Visit(this, param);
           ret[1] = e.Right.Visit(this, param);
           switch (e.NodeType)
           {
               case ExpressionType.Add:
                   return this.VisitorAdd(e, param, ret);
               case ExpressionType.Subtract:
                   return this.VisitorSubtract(e, param, ret);
               case ExpressionType.Multiply:
                   return this.VisitorMultiply(e, param, ret);
               case ExpressionType.Divide:
                   return this.VisitorDivide(e, param, ret);
               case ExpressionType.Modulo:
                   return this.VisitorModulo(e, param, ret);
               case ExpressionType.And:
                   return this.VisitorAnd(e, param, ret);
               case ExpressionType.Or:
                   return this.VisitorOr(e, param, ret);
               case ExpressionType.LT:
                   return this.VisitorLT(e, param, ret);
               case ExpressionType.LE:
                   return this.VisitorLE(e, param, ret);
               case ExpressionType.GT:
                   return this.VisitorGT(e, param, ret);
               case ExpressionType.GE:
                   return this.VisitorGE(e, param, ret);
               case ExpressionType.EQ:
                   return this.VisitorEQ(e, param, ret);
               case ExpressionType.NE:
                   return this.VisitorNE(e, param, ret);
               case ExpressionType.BitwiseAnd:
                   return this.VisitorBitwiseAnd(e, param, ret);
               case ExpressionType.BitwiseOr:
                   return this.VisitorBitwiseOr(e, param, ret);
               case ExpressionType.BitwiseXor:
                   return this.VisitorBitwiseXor(e, param, ret);
               case ExpressionType.Coalesce:
                   return this.VisitorCoalesce(e, param, ret);
           }
           return null;
       }
   }


   public static partial class Utils
   {
       public static object[] VisitList(this StaticList<Expression> el, ExpressionTreeVisitor etvisitor, object param)
       {
           object[] ret = new object[el.Count];
           for (int i = 0, n = el.Count; i < n; i++)
               ret[i] = el[i].Visit(etvisitor, param);

           return ret;
       }
       public static object[] VisitList(this StaticList<Binding> el, ExpressionTreeVisitor etvisitor, object param)
       {
           object[] ret = new object[el.Count];
           for (int i = 0, n = el.Count; i < n; i++)
           {
               ret[i] = el[i].Visit(etvisitor, param);
           }
           return ret;
       }
       public static object[] VisitList(this StaticList<ParameterExpression> el, ExpressionTreeVisitor etvisitor, object param)
       {
           object[] ret = new object[el.Count];
           for (int i = 0, n = el.Count; i < n; i++)
           {
               ret[i] = (el[i] as Expression).Visit(etvisitor, param);
           }
           return ret;
       }
       public static object Visit(this Binding e, ExpressionTreeVisitor etvisitor, object param)
       {
           return null;
       }
       public static object Visit(this Expression e, ExpressionTreeVisitor etvisitor, object param)
       {
           return etvisitor.Visit(e, param);
       }
       public static object Visit(this Expression e, ExpressionTreeVisitor.VisitorDelegate etvisitordelegate, object param)
       {
           ExpressionTreeVisitor visitor = new ExpressionTreeVisitor();
           visitor.AssignVisitorTo(etvisitordelegate, ExpressionTypeTree.All);
           return e.Visit(visitor, param);
       }
   }


   public class ExpressionTree : Expression, INode<Expression>
   {
       ExpressionTreeList _Children = new ExpressionTreeList();
       Expression _expression;
       bool _isdirty = false;
       bool _isbuilding = false;

       public static object TreeBuilder(Expression expr, object param, object[] sons)
       {
           ExpressionTree exprtree = param as ExpressionTree;
           if (exprtree.Value == expr)
           {
               for (int i = 0, n = sons.Length; i < n; i++)
               {
                   object[] group = sons[i] as object[];
                   if (group != null)
                   {
                       foreach (object obj in group)
                           exprtree.Children.Add(new ExpressionTree(obj as Expression));
                   }
                   else
                       exprtree.Children.Add(new ExpressionTree(sons[i] as Expression));
               }
           }
           return expr;
       }


       public ExpressionTree(Expression expr)
           : base(expr.NodeType, expr.Type)
       {
           Value = expr;
       }

       private void BuildTree()
       {
           _isbuilding = true;
           ExpressionTreeVisitor visitor = new ExpressionTreeVisitor();
           visitor.AssignVisitorTo(new ExpressionTreeVisitor.VisitorDelegate(TreeBuilder), ExpressionTypeTree.All);
           _expression.Visit(visitor, this);
           _isbuilding = false;
           _isdirty = false;
       }


       public Expression Value
       {
           get
           {
               return _expression;
           }
           set
           {
               _expression = value;
               _isdirty = true;
           }
       }
       public INodeList<Expression> Children
       {
           get
           {
               if (_isdirty && !_isbuilding) BuildTree();
               return _Children as INodeList<Expression>;
           }
           set
           {
               _Children = value as ExpressionTreeList;
           }
       }
   }


   public class ExpressionTreeList : List<INode<Expression>>, INodeList<Expression>
   {

   }

}

and the tree structure:

Tree.cs

using System;
using System.Collections.Generic;
using System.Collections;
using System.Windows.Forms;

namespace DataStructure
{
   public interface INode
   {
       object Value { get; set;}
       ICollection Children { get;}
   }
   public interface INodeList : IList<INode> { }
   public interface INode<T>
   {
       T Value { get;            set;        }
       INodeList<T> Children
       {
           get;
           set;
       }
   }
   public interface INodeList<T> : IList<INode<T>>
   {
   }

   public class Node<T> : INode
   {
       private T data;
       private NodeList<T> _children = null;

       public Node() { }
       public Node(T data) : this(data, null) { }
       public Node(T data, NodeList<T> children)
       {
           this.data = data;
           this._children = children;
       }

       public T Value
       {
           get
           {
               return data;
           }
           set
           {
               data = value;
           }
       }

       public NodeList<T> Children
       {
           get
           {
               return _children;
           }
           set
           {
               _children = value;
           }
       }

       #region INode Members

       object INode.Value
       {
           get
           {
               return this.Value;
           }
           set
           {
               this.Value = (T)value;
           }
       }

       ICollection INode.Children
       {
           get { return this.Children; }
       }

       #endregion
   }
   public class NodeList<T> : List<Node<T>>
   {
       public NodeList() : base() { }

       public NodeList(int initialSize)
       {
           for (int i = 0; i < initialSize; i++)
               base.Add(default(Node<T>));
       }

       public Node<T> FindByValue(T value)
       {
           foreach (Node<T> node in this)
               if (node.Value.Equals(value))
                   return node;
           return null;
       }
   }

   public delegate object TreeVisitor<T>(INode<T> arg, object param, object[] sonreturn);
   public delegate INode<T> TreeTransformer<T>(INode<T> arg, object param, INode<T>[] sonreturn);



   public static partial class Utils
   {
       public static object Visit<T>(this INode<T> arg, TreeVisitor<T> treevisitor, object param)
       {
           return treevisitor(arg, param, arg.Children.VisitList<T>(treevisitor, param));
       }
       public static object[] VisitList<T>(this INodeList<T> arg, TreeVisitor<T> treevisitor, object param)
       {
           object[] ret = new object[arg.Count];
           for (int i = 0, n = arg.Count; i < n; i++)
           {
               ret[i] = arg[i].Visit(treevisitor, param);
           }
           return ret;
       }
       public static INode<T> Transform<T>(this INode<T> arg, TreeTransformer<T> treetransformer, object param)
       {
           return treetransformer(arg, param, arg.Children.TransformList<T>(treetransformer, param));
       }
       public static INode<T>[] TransformList<T>(this INodeList<T> arg, TreeTransformer<T> treetransformer, object param)
       {
           INode<T>[] ret = new INode<T>[arg.Count];
           for (int i = 0, n = arg.Count; i < n; i++)
           {
               ret[i] = arg[i].Transform(treetransformer, param);
           }
           return ret;
       }

       public static INode<T> Copy<T>(INode<T> arg, object param, INode<T>[] sonreturn)
       {
           Node<T> ret = new Node<T>();
           foreach (Node<T> son in sonreturn)
               ret.Children.Add(son);
           return ret as INode<T>;
       }
       public static object ToTreeNodes<T>(INode<T> arg, object param, object[] sonreturn)
       {
           TreeNode ret = new TreeNode(arg.ToString() + ":" + arg.Value.ToString());
           foreach (object son in sonreturn)
               ret.Nodes.Add(son as TreeNode);
           return ret;
       }
   }
}

About schyzophreny, C#3 intelligence and runtime stupidity

2006-03-09T12:05:00.000-08:00

On my way toward a flexible application to perform queries on the vast amount of information my trading desk produces everyday, I was delighted to meet with C#3 and Linq functionnalities. Design time I always thought such a transversal approach was needed and I was surprised to remember that I developped a similar API for VB back in the old days :) Now I could have cutting edge Microsoft functionnalities and exceptionnal compiler intelligence working for me. Just think about this :

var queries = new List<IEnumerable>();

var query1 = this.GetCustomerList().Where( p => p.CompanyName.Length == 4);

queries.Add(query1);

This simple line declare function, builds a query, infers return type... Also while I was typing it, I benefited from code completion, and if I add tried to assign it to a wrongly typed variable, I would have been warned of such probable mistake.What a great endeavour from a smal code line ! Yeah but as you may see from my code, I am not a business genius. My query does not add a lot of value for the Market Intelligence people in search of which customer is important. They'd probably So I'd like my users to type in their own queries. That way, market intelligence people will build their own queries, managers their have own other set too, and I wont coerce them into my limited imagination. Runtime definition of queries If I want to do this, here is how I could do to make it work :

define a langage
build a parser to go from string to a tree of command (an expression tree in Linq)
build a visitor for this tree to build the code to run using reflection
evaluate

Compare this with the ease I add with the previous query building. And with this solution I have lost all the intellisense, and many other prerun features....

Now what has changed from a functionnal point of view? Nothing, I just want to add some queries to my list...

Beside, all the logic I want my to present to my users already exists in the C# compiler.. Although it is very interesting, why would I need to reinvent the wheel? Partial runtime and dynamic compilation The idea is that I want to tag part of my code, the one which define the queries, as being modifiable, until my program really needs it.

var queries = new List<IEnumerable>();

var query1 = this.GetCustomerList().Where( p => p.CompanyName.Length == 4);
queries.Add(query1);

[userpoint("DefiningQueries")]

foreach (var query1 in queries) {

..

If this tag is seen, I want the compiler to validate my code, and to store it as an expression, not compile it. Then, at runtime, I want to be able to make all the variables available at this place in my code known in a reflection-like manner, only this time reflection is not linked to an assembly or a class, but to a location in code. This helps me pre-validate the user input. And I also want to inject code, and compile it in the specific context of that [Userpoint] !

        public void AddExpression(string expr)

        {

           CompilerError[] ces = Microsoft.CSharp.Compile(expr, this, "DefiningQueries");

            var queries = Code.Userpoint("DefiningQueries").getVariable("queries");

            queries.MethodCall("Add", new objet[] { ces } );

        }

That way, in a first part of the program, I load my general form, and the environment which enables my users to edit their queries. When a query is added, it is actually added as parsed some code to my section. I make full reuse of everything that already exists at the csharp compiler level. So do you think this concept of partial runtime can be useful in other cases?

Important aspects of c#

2005-10-29T11:37:00.000-07:00

There are plenty of places to read articles about one tech in .Net Each of them tells you about one different aspect, but how to find which one to really know? This is a repository of what aspect are I thought were important. Can you think of some others?

Generics : generics are useful to strong types transversal notions
BindindSource behaviour (how the construct a view from the argument) and binding structure like bindinglist
Linq : the ultimate tool for projecting out data : If you need smart plumbering, agregating of data structure

Reflection : it is useful when you want at runtime to manipulate

Continuations : If you need, against conventionnal wisdom, to perform a high level operations within a lower level context, continuation is an elegant way to separate those not be trapped and to express compactly your code

Closures : closures captures at one point in code all the available context. They are very handy for dealing with asynchronous steps.

Tag: csharp

The big software merge : a distributed data and metadata namespace (anything left?)

2005-10-21T11:17:00.000-07:00

Nowadays peer to peer applications are powerful from the viewpoint of the 90's we. But I guess that the confluence of p2p with a growing trend of the web is going to make this a killer app that will transform the computing world as we know it. Think AJAX. It is a great technique, and you might think it is a slick and handy presentation. or a bad programming concept. Traditionnal apps present data. AJAX through its slick presentation enables to expose not just data but the data model as well. Think of those Gmail pages where you enter a new contact easily. or that dynamic autocompletion feature you like. The point is, you're not just entering strings, you are entering a contact. that is precisely what is a datamodel. You write an email, that field must be a contact. So those nice gmail guy's help you with entering a contact. Now what is the link with p2p? Well, precisely, the datamodel, or its current lack of it. Currently, raw data is exchanged, with an embryonnic, altavista like, search facility. Beside the technical prowess of distributing download, the p1p story from a functionnal perspective sounds like : Some people have stuff stored. You can download them. Which to me sounds like a very static web era story. Now if you add to this story the trend that I discerned in AJAX, you can replace that story with

Some people have stuff stored ----> Some namespaces are published, aka "MyNeighbourTom", wich contains stuff "StartrekMovie"
stuff ---> this stuff is actually object whose data model is transmitted : MyNeighbour.StartrekMovie.BitRate for instance
I download it ---> I can of course still download it, or perform actions on those like MyNeighbour.ThisDocument.Print.

Furthermor, as you know the data model of your query, a computer can interpret that itself independantly of the actual action transmitted. for instance building up a common portal between friends exposing all the music we have.

So the notions at play here, that we now see develop, and which will among others radically change p2p and the internet are : .Namespace sharing .Data AND metadata publishing Followup : the powershell published by microsoft gets closer to those notions, where "everything is an object", data and metadata are merged in one envrironment (you can create object on the fl, you can extend an object type on the fly too) but lacks GUI feature and p2p dimension. This is all evolving very fast..

Organizing information

2005-10-15T09:50:00.000-07:00

There is many information available to us, but as we can see in the information age what is important is not information itself, but how do we structure that information, in terms of relevance, of classification etc.. RSS has been useful because it delivers such a projection, which consists of the most recent information, from a selected subset of sources, who decides themselves that such and such information is of value to their reader, hence should be available through this channel. Take another information. For instance bus stop times. yes, they are available for me on www.ratp.fr after 4 or five hops. Oh and wouldn't it be good if after I checked my bus stop to retrieve the weather for tonight so I know how to dress. And may be during the day I also would like to check if my stocks went up or down, not that it would change anything but I just like it. Would I spend 30 minutes everyday on this? no then I prefer not to. But had their be a simple service which would allow me to suscribe to those information once I sure would go and do that. One of my friend is interested in the dollar rate, which is important for him to send money to his place. Another one wants to build a little app that for a particular functionnality reads various financial analysts reports from different website and synthetize them. Point of this is: The content published is a projection of datas which fits the needs of various publishers. We want to project the datas on our needs. We should be able to define data sources, independently of the data provider, group and categorize those data as we see fit, and consume those datas as we would like to. So I started a 'personnal projection project', which will enable people to define their own set, and publish this set. This is valuable for personnal use, but also for public use, letting people share not the data itself, but the location of the data, its description, its category etc.. Those data will be exported through standard web service, and of course customisable RSS feed, for integration into custom application, web pages, RSS readers etc. Isn't it funny I wrote all that without the expression web2.0 in?

2005-10-07T12:51:00.000-07:00

Because finding the correct tool and minimizes impedance mismatch is getting 50% of the work done , this is a great article as far as langage itself is concerned : http://pico.vub.ac.be/~wdmeuter/RDL04/papers/Meijer.pdf

Wrong architecture

2005-10-06T13:24:00.000-07:00

I know this is all very basic yet this is a predominant pattern. Shit happens where low level logic guide high level logic. For instance in Excel say you have the following piece of shode: Function doSomething( no arguments ) Volatility100_1Y = cells("A16") Volatility110_1Y = cells("A17") ...etc... ..then some computation .. cells("A18") = result1 cells("B18") = result2 End So here a low level idea (the specific format of the volatility organised in row) is imposing its format on what is an input of this process. A first step would be to have Function doSomething(Range inputVol, Range OutPutResult) Volatility.reads(c1) ...etc... ..then some computation .. result.write(cells("A18")) End Here it is the Volatility object that writes itself to the cells, not the little low level "A16" cell, who does not know shit about what a volatility is, who constraints the process nonetheless. I think this is called inversion of control by computers scientists, and it relates to object orientation. But it also relates to respecting a common sense abstraction hierarchy where high level guides low level, not the other way round. Which in the end of your application is where you want to go anyway.

exchange rate

2005-10-02T02:01:00.000-07:00

Why can the exchange rate be confusing to trade when it is just a unit of conversion? Let's take an example. For an engineer, the speed of a car is 100 km/h and varies in time. But the kilometer of the hour itself are not seen varying themselves, unlike in currency rate. Say we go from .8 to 1.2 USD/EUR, the dollar would have weaken ! Which is why "USD per EUR" is called by cambists "EUR-USD" so that they can identify this number as "the spot of the Euro (rel to USD)" So if you want to sell EUR, you will get the lowest quote, and if you want to buy, you'll get the highest. Rule of thumb: for any currency pair, you take the currency at the denominator, you express your order in term of that currency. then you know if you are long or short the quote.