the power of every computer science concept lies in its composability

And indeed, many progress have been to basically put what we considered “context” into  an explicit composable receptacle. Virtual Machine, global variables hunt, reentrancy, transaction, namespaces, it’s all over the place. Composing is key.

Functional programming being really all about composabilty, it is natural to see a lot of recursive structure such as trees, but there is a really useful extension to this that is not so well known, called a Zipper.

The concept is quite general and could be implemented in any langage, but we’ll use F# to illustrate, as it bends itself nicely to such structures.

Tree

This is a way you can declare a tree type in F#. It is made of either, a leaf, or, a node, holding a value (of generic type ‘a), and 2 subtrees of similar generic type.

Pattern match then allows us to manipulate such a structure, and recover the information stored within it.

The goal of that insert function, whose name contains BST for ’Binary Search Tree’, is to make searching (much) faster : as you can see, we keep the tree ordered upon insertion, so that finding a number is subsequently simpler: If we stored random numbers, each layer would be fully populated so that 2^d numbers could be stored in a tree of depth d. For finding a number we’d had to traverse the tree making d = log_2 n  comparaisons for selecting which way to go : at each step, the size of potential candidate is halved by two, as we discard 1 fully populated branch.

If our source of numbers at insertion was not random but ordered, for instance, our tree would grow in one direction only, and each level would be populated by just one value. to find 1 number among n others, we similarly would have to make d comparisons, but this time instead of halfing the number candidates, we’d merely remove one. Our tree would be very much akin to a list, for which we have to scan through all the items to know if a number is present. That is why we probably should rebalance our tree if we have no knowledge on the data source, to keep it closer to a complete binary tree

Binary Search Tree exists independently of Trees, and this just illustrates a common way to operate on recursive structures in F#.

So pattern match allows us to drill down the hierarchy of nodes and, since the root node can reach every other node, this seems good enough.

But what if you know you’ll have to heavily focus on a sub-tree for some time in a large tree ? How could you zoom on that subtree, perform all your operations, and then yields back the whole thing. Or may be your problem at hand might just be easier to write with the ability to move everywhere, including up and not just down.

Clearly, being able to move efficiently in the tree from every node, not just the root, seems like a valuable thing to have.

Zipper

This is where the Zipper comes in : The Zipper is an equivalent representation of a Tree, with the notion of a ‘current’ location, which can go be moved up, right, left, etc..

Conversely, a Tree is a special case of a Zipper with its current location being always at the top.

The general idea is that we split a structure into a substructure of interest, and a modified structure with a ‘hole‘ in it, and reconstruct some functions operating on that to move the hole. So you can see how the notion of a Zipper can really be general and apply on more that just tree.

[This structure holding a hole is 'equivalent' in some sense to a structural 'derivative'. although interesting at concrete level to give a different perspective, I dont see how this general typelevel notion of derivative can be useful given the lack of actionable typelevel operations. It would be quite cool to have such operations, but given the lack of efficient, down to earth way this is unfortunately only hot air (which could be enabled - yet another thing.... - by staged type programming  which will probably come from dynamic langage someday as they'd benefit as well... ) ]

The Zipper here is a record and contains a tree, which is the current focus. But, most importantly, it contains all the information discarded to go from the root a full tree to the root of that subtree which is the focus. At each level, focusing on a subtree means selecting a direction, discarding the node value, discarding the subtree not being focused on.

This set of information allows that structure to be closed under the operations we want : up, left, right : they all take a Zipper in, and yield a zipper out.

You can then test those methods like so. The last line for instance the focus with another tree (in that case itself) and gets the completed tree back, which illustrated the  ease of manipulation you get from such structure.

related links :

• Haskell zipper intro from ‘learn you a Haskell for great god’
• Another F# implementation with a nice symetry for the ‘path’ type and a slightly different semantics :   our ‘right’ is equivalent of their ‘down’ then ‘right’. dealing with n-ary tree, they had to split both notions

( please dont hesitate to point errors or further links.. )

www.macledkeyboard.com

The Luxeed LED Keyboard has 430 color LEDs beneath the keycaps. The color of each key can be individually configured to match your application or mood

Daphne Koller – Technology as a Passport to Personalized Education – NYTimes.com

As a society, we can and should invest more money in education. But that is only part of the solution. We need to significantly reduce those costs while at the same time improving quality.

Graphical Models and Inference  MT11

These are the contents of 16 lectures in MT11.

fseye – Ending the era of printf REPL debugging for F# Interactive

FsEye is a visual object tree inspector for the F# Interactive. Taking advantage of the built-in WinForms event loop, it listens for additions and updates to variables within FSI sessions, allowing you to reflectively examine properties of captured values through a visual interface. It also allows you to programmatically add and update eye watches, effectively ending the era of printf REPL debugging.

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.

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)

Hacker School

Hacker School is a three-month, immersive school for becoming a better programmer. It’s like a writers retreat for hackers. We (Nick, Dave and Sonali) run the program every four months in New York and meet Mondays, Tuesdays, Fridays and Saturdays from 11am to 7pm. We provide space, time to focus, and a friendly community dedicated to self-improvement

Exo7 : Exercices de mathématique

Le projet Exo7 propose aux étudiants des fiches d’exercices de mathématique avec indications et corrections de niveau L1/Math Sup, L2/Math Spé, L3/Licence. Ces fiches sont élaborées, corrigées et validées par des enseignants du supérieur.

Vous trouverez plein d’autres exercices dans Exo7 pour les profs, mais ils ne sont pas tous corrigés.

Nihongo o Narau – Learn Japanese

Welcome to Nihongo o Narau. This site is dedicated to teaching Japanese to speakers of English.

CVXGEN: Code Generation for Convex Optimization

CVXGEN: Code Generation for Convex Optimization
Example: Portfolio optimization
This example, from finance, is a basic portfolio optimization problem. For some more details, see Boyd and Vandenberghe, 4.6.3.

faculty.washington.edu/mfazel/portfolio-final.pdf

Portfolio optimization with linear and fixed
transaction costs
Miguel Sousa Lobo · Maryam Fazel · Stephen Boyd

Biostatistics Ryan Gosling !!!

Biostatistics Ryan Gosling !!!

Stories In Flight | HTML5/CSS3 Cheatsheet

Here are some simple cut-and-paste examples of HTML5/CSS3 features that are currently (early 2011) usable across a number of web browsers

Courses

Courses. Taught by Hadley Wickham.

Ruby Graph Library

Ruby Graph Library (RGL)

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.

LiteratePrograms:Welcome – LiteratePrograms

LiteratePrograms is a unique wiki where every article is simultaneously a document and a piece of code that you can view, download, compile, and run

Thiel Fellowship

Thiel Fellows are given a no-strings-attached grant of $100,000 to skip college and focus on their work, their research, and their self-education

30 Days to Learn HTML & CSS – Free Tuts+ Premium Course

We created 30 Days to Learn HTML & CSS because we believe everyone has the right to learn how to build wonderful things on the web.

people.rit.edu/jcdicsa/courses/SML/

Statistical Machine Learning // The main materials for the course will be lecture notes, along with supplementary readings from The Elements of Statistical Learning and Convex Optimization

Data mining, forecasting and bioinformatics competitions on Kaggle

Kaggle is a platform for data prediction competitions that allows organizations to post their data and have it scrutinized by the world’s best data scientists. In exchange for a prize, winning competitors provide the algorithms that beat all other methods of solving a data crunching problem.

RSpec Documentation – Relish

This is the official documentation site for RSpec-2. Much of the documentation you see here is written with Cucumber, which, like RSpec, provides executable documentation. The Cucumber features you see here have all been run against RSpec’s codebase, serving as specification, documentation and regression tests of the behavior

Learn Ruby with the EdgeCase Ruby Koans

The Koans walk you along the path to enlightenment in order to learn Ruby. The goal is to learn the Ruby language, syntax, structure, and some common functions and libraries.

#183 Gemcutter & Jeweler – RailsCasts

Gemcutter is a new service for hosting RubyGems, and Jeweler provides an automated way to release versions of a gem.

Sirupsen and his codeabouts

I’ve always run Ruby, and I’ve always used RVM. But it’s not until recently when I attended Aarhusrb and @chopmo gave a talk on RVM, that I realized how wrong I was using RVM. Basically, I’m somewhat always using system Ruby, installing all gems with sudo

http://puzzlenode.com/

PuzzleNode is a site for coders who enjoy to work on challenging problems, and is inspired by similar efforts such as Project Euler and the Internet Problem Solving Contest . It also serves as an entrance exam of sorts for folks looking to join Mendicant University.

www.math.wustl.edu/~sawyer/hmhandouts/Wishart.pdf

The Jacobian of the Inverse of a Matrix is..

Are they trying to kill Reader so that we move on to the half backed Google Plus ??