There is theory, and then there is practice. Yesterday was theory, today is practice.
Everyone and its dog has to manipulate Excel files. They often contain typed data, in tables. So why not write, in the footsteps of the distinguished, a Type Provider for it ?
So here is a type provider to consume those data from within absolutely any langage supporting Type Providers. Which means F#.
You can specify the workbook name, and then a named range or a sheet (data starts at A1 then), and if the underlying Excel type should be considered or if it should just be seen as a bunch of strings.
The Excel Type Provider : please fork it, improve it, for the greater good.
If you wanted to have access to all the “objects” defined in wikipedia directly from within your programming environment, how would you do it?
Type Providers, a new and promising feature of F#, act like an augmentation of your compiler and IDE, and allow you to import such objects, the ones present now, but also the new one that might be published tomorrow.
They make your IDE/compiler aware of such new types, just like when you add a good old dll to it, except those type are generated “on the fly”, dynamically (from the point of view of the Type Providers that makes this connection and produces the types), but, from the point of view of your compiler, they are “static”, just like any other types.
Indeed, the dichotomy between “static” and “dynamic” lays in the eye of the beholder. Even a regular static type from a DLL has to be ‘produced’ in some way, so the “static” only relates to which stages the type is at, and from where you look at it.
This opens a more profound door, which is particularly well placed to become the ‘next thing’ on the internet in my view, and that is ‘execution level’. If it sounds as barbaric as peeer to peer was before people knew what p2p is, it is normal, it is not a coincidence. In order to understand the importance of this idea, we need to step back a bit, understand what happens with types, and then see where we can extend the mechanism.
When we describe actions, we do so using structures that are adressable and recognized as part of the vocabulary of our programming environment.
“Type providers” are mechanism to enrich the vocabulary of this environnement based on a source that we specify in that same environment. the source itself can evolve in time, and the vocabulary added in our environnement will itself evolve in time.
But “type providers” are themselves programs. so we are lead to imagine that there is our direct environment, which we will call the ground 0 level, which is fed vocabulary by an deeper world, level -1.
In order to our program at ground 0 to tun, it needs to make sense from a vocabulary point of view. In order to makes sense, ground -1 has to actually run to provide the types, or vocabulary. And this idea is naturally extensible to some leve -1, -2, -3 etc..
This is where the peer to peer idea comes into play. If anything the internet is good at dealing with decentralisation. this mostly applied to data. peer2peer showed us that you can really leverage decentralisation to insure that all connection run at their maximum nominal speed. git, and its web counterpart Github nailed it when it comes to decentralized history production. Type Providers, despite their strength, are just a small scale, non recursive, non decentralized, static window into the next big battle, which is “Type production”.
Practically, the centralized nature of programming at binary level is a very concrete and major problem for code production of every nature, as the complexity of modeling a domain grows exponentially with the complexity of the domain itself.
So, watch out, you ain’t seen nothing yet, and the battle has just officially begun.
A concrete exemple start at 18′ (wait a few sec after clicking to read)
Vous trouverez plein d’autres exercices dans Exo7 pour les profs, mais ils ne sont pas tous corrigés.
RGL is a framework for graph data structures and algorithms.
The design of the library is much influenced by the Boost Graph Library (BGL) which is written in C++ heavily using its template mechanism. Refer to www.boost.org/libs/graph/doc for further links and documentation on graph data structures and algorithms and the design rationales of BGL.
A comprehensive summary of graph terminology can be found in the the graph section of the Dictionary of Algorithms and Data Structures at www.nist.gov/dads/HTML/graph.html.
The presentation for google reader, using the new style with lots of space is a plain obvious and complete misfit for Google Reader.
Are they trying to kill Reader so that we move on to the half backed Google Plus ??
I have a repository in github where I plan to push the work for the exercises of ml-class.org
Having completed the exercises 1 and 2 onto my master branch, here is what my git history looked like :
(master) $ git lg * fe0fea7 - (HEAD, master) 0-plot data (Nicolas Rolland 7 days ago) * da30d65 - 5-6-costfunctionreg et gradient (Nicolas Rolland 7 days ago) * 6c1f4a3 - 4-predict (Nicolas Rolland 7 days ago) * 22f6d98 - 2- cost function (Nicolas Rolland 7 days ago) * c1e50ce - 1-sigmoid (Nicolas Rolland 7 days ago) * 76c8b48 - 2nd exercize (Nicolas Rolland 7 days ago) * bf9f683 - normal eqtn price estimation (Nicolas Rolland 8 days ago) * 5cd7d0b - normal eqtn (Nicolas Rolland 8 days ago) * 1eefdd5 - estimate house price (Nicolas Rolland 8 days ago) * b2aca44 - rate learing plot (Nicolas Rolland 8 days ago) * 617423e - gradientdescentMulti (Nicolas Rolland 8 days ago) * 1b2d951 - computecostMulti (Nicolas Rolland 8 days ago) * bba2916 - featurenormalize (Nicolas Rolland 8 days ago) * fe7ba87 - gradientdescent (Nicolas Rolland 8 days ago) * 637efdd - computecost (Nicolas Rolland 8 days ago) * 1d0d2e2 - plotData (Nicolas Rolland 8 days ago) * dc297c9 - warmup (Nicolas Rolland 8 days ago) * fd7b7fa - first exercize (Nicolas Rolland 8 days ago) * 355e42a - first commit (Nicolas Rolland 8 days ago)
That is, a nice sequential history. I decided, for reasons that are still behind my full conscious knowledge at this time, in order to push each exercise independently on github, to create a topic branch for each exercise. Therefore I added some branch, by simply typing
(master) $ git co bf9f (master) $ git branch exo1 (master) $ git co master (master) $ git branch exo2
That sets the branch name all right, but my branch exo2 contains the history of exo1.
It turns out it is quite easy to selectively apply only the change from exo1 to exo2 to a certain starting point, in my case, the first commit 355e42 :
(master) $ git rebase --onto 355e42 exo1 exo2 First, rewinding head to replay your work on top of it... Applying: 2nd exercize Applying: 1-sigmoid Applying: 2- cost function Applying: 4-predict Applying: 5-6-costfunctionreg et gradient Applying: 0-plot data
And voila.
If I check my log I can see :
(exo2) $ git lg * e3ee4ea - (HEAD, exo2) 0-plot data (Nicolas Rolland 6 seconds ago) * 3d58766 - 5-6-costfunctionreg et gradient (Nicolas Rolland 6 seconds ago) * 8743366 - 4-predict (Nicolas Rolland 6 seconds ago) * 6c327e9 - 2- cost function (Nicolas Rolland 6 seconds ago) * ac916d3 - 1-sigmoid (Nicolas Rolland 6 seconds ago) * f3db3f1 - 2nd exercize (Nicolas Rolland 6 seconds ago) * 355e42a - first commit (Nicolas Rolland 8 days ago)
So my exo2 branch has no knowledge of the modifications from exo1.
I came from a single linear history and split that into 2 different branches independent of each other.