~ Get To Know Sharath Sury In This Brief Bio Video ~

Thanks for watching!

Cameron Wilson and Peter Harsha have written a nice piece in the September CACM highlighting the challenges in changing K-12 education policy as it relates to computing.  They hit on all the big points, from the challenges of getting computing education to “count” for anything in high schools, to teacher certification, to “No Child Left Behind.”  Of course, I’m also pleased that “Georgia Computes!” gets highlighted.  Recommended for understanding why it’s so hard to get more and better computing education into schools!

The July 2009 CACM also has a great point/counterpoint piece by Robert Dewar and Owen Astrachan asking “Is CS Education in the US headed in the wrong direction?”  I’m not going to give my personal opinion on the pieces, because I solicited both articles for CACM.  I am really pleased with both position papers, and how the overall piece came out.  It’s really about what do we want from our education system — what does an undergraduate degree in computing mean?

The July 2009 Communications of the ACM has an interesting article by Matthias Felleisen and Shriram Krishnamurthi Why Computer Science Doesn’t Matter with the great subtitle “Aligning computer science with high school mathematics can help turn it into an essential subject for all students.”  The argument that Matthias and Shriram are making is that we can use programming to teach mathematics better, and help students learn both.  In so doing, we prevent marginalization of computer science and support an important goal of the American education system, the teaching of “‘rithmetic.”

It’s a good argument and one that I support.  I am dubious about some of the education claims made in the argument, like “we have already seen our curricular approach…help students raise their alebra scores” and “Formal evaluation shows the extremely positive impact this curriculum has…”  (I’ve been searching through the sites given in the article, but can’t find peer-reviewed, published papers that support these claims.)  But these are really minor quibbles.  Having written one of these pieces, I know that the tyrany of 1800 words is severe, and the authors can be excused for not providing background citations to the studies supporting their claims.  Instead, I’d like to provide some of the background literature that supports their claim.

Can we use programming to help students learn mathematics?  Absolutely!  Probably the most famous study supporting this argument is Idit Harel’s dissertation work on Instructional Software Development Project (ISDP). Idit had fourth graders write software in Logo to teach fractions to third graders.  She found that a real synergy occurred between the concepts of programming and the concepts of mathematics, and her students ended up learning more about both compared to another class.  Yasmin Kafai (who just moved to Penn from UCLA this last year) continued this project, exploring novel collaboration models (e.g., the fourth graders become fifth grade “consultants” as another cohort of fourth graders helps another cohort of third graders) and expanding from mathematics into science.  My own dissertation explored the synergy between physics and programming.  My results weren’t as strong — I had good physics learning, but not good computer science learning.  I suspect the problems were the challenge of making real learning in only a three week summer workshop, and not having the kinds of IDE’s that Matthias and Shriram are calling for.

“Our community must realize that minor tweaks of currently dominant approaches to programming won’t suffice.”  Completely agreed, and the best argument for this point came from Bruce Sherin’s powerful dissertation (with Andy diSessa at Berkeley).  Bruce taught two groups of students lessons in physics, one using programming and one using algebra.  (Andy would probably argue with Matthias and Shriram, “The ideal language and the IDE for imaginative programming are still to be designed.”  Over 20 years ago, Boxer implemented much of what they’re calling for.)  Bruce found some really interesting differences between what was learned via each form of notation.  For example, programming was better for figuring out causality and sequencing. An algebraic formula like x = x0 + vt leaves invisible to the novice that the t is what will typically vary in that equation.  On the other hand, algebra was better for understanding balance and equilibria.  A formula like F=ma works in both directions:  increase the mass or acceleration and the force increases, or if the force declines, then either the mass or the acceleration must have declined.  Most programming languages do not make evident how constraints work in the world.  The media extensions that Matthias and Shriram describe help address some of the challenges Bruce found when students had a single physics concept (e.g., an object moving because it’s location changed) being represented by multiple lines of code.

“As computer science educators, we must also demand a smooth, continuous path from imaginative programming to the engineering of large programs.”  Alan Kay has been making this argument for years.  He refers to the concept of Omniuser who can move from scripting in E-Toys, to changing how the levels close to the metal of the machine work, all with a single system and (hopefully) a single notation.  His STEPS effort is seeking to build such systems. In particular, Alan and his team are exploring “systems math” which is a kind of powerful mathematics that can only really exist in the powerful medium of programming.  Thus, STEPS gives us a way to go beyond just support “‘rithmetic” to support powerful new kinds of mathematics learning.

I’m a big fan of Scheme and consider DrScheme to be one of the finest pedagogical IDE’s ever created.  TeachScheme is a brilliant curriculum.  My guess is that careful studies of the effort would support many of the claims being made by Matthias and Shriram.  More importantly, though, I believe that they’re right that programming could actually improve mathematics learning.  Doing it in such a way that students’ mathaphobia doesn’t drive even more students from computer science is a real challenge.  An even bigger challenge is doing it in such a way that can gain the support of organizations like NCTM and that meets the mathematics standards in our schools. As they say, “Any attempt to align programming with mathematics will fail unless the programming language is as close to school mathematics as possible.”  It’s more than just the programming language — the whole package (curriculum, IDE, language) has to look and feel like mathematics to make it successful with the mathematics education community.

Implementing data structures in a way that uses efficiently memory should always be on your mind. I do not mean going overboard and micro-optimizing memory allocation right down to the bit. I mean organize data structures in memory so that you can avoid pointers, so that you can use contiguous memory segments, etc. Normally, minimizing storage by avoiding extra pointers when possible will benefit your program in at least two ways.

First, the reduced memory requirement will make your data structure fit in cache more easily. Remember that if pointers are 4 bytes long in 32 bits programming, they are 8 bytes long in 64 bits environments. This yields better run time performance because you maximize your chances of having the data you need in cache.

Second, contiguous memory layouts also allow for efficient scans of data structures. For example, if you have a classical binary tree, implemented using nodes having each two pointers, you will have to use a tree traversal algorithm, possibly recursive, to enumerate the tree’s content. If you don’t really care about the order in which the nodes are visited, what’s quite cumbersome.

It turns out that for special classes of trees, complete trees, there is a contiguous, and quite simple, layout.

Consider the following figure:

A complete binary tree

You notice that each node is numbered, and that you have the following relations holding between the nodes:

For a node , you have…

• that its parent is given by ,
• that its left child is given by ,
• that its right child is given by ,

Assuming that the root is numbered . This suggests the layout:

The tree, as seen in a flat layout

where the arrows corresponds to parent/child links.

The proof that this mapping works correctly is somewhat self-evident. What is less evident, is that such mappings exist for trees with higher branching factors. In general, if you have a tree with a branching factor of , you will have that, for a node ,…

• the parent is given by ,
• the children are given by , , … .

So, plugging in the previous equations leads us to the binary tree case. The case corresponds to higher-order three. Letting gives us a layout for quad-trees, which are extensively used in computer graphics. yields octrees which are also used in computer graphics applications, such as collision detection, ray tracing and volume rendering. Note that if you put , you get a list, that the parent is given correctly by and the (only) child by .

The addresses of the first node in a row, for:

• , is given by 0,1,3,7,15,… or , is Sloane’s A000225.
• , is given by 0,1,4,13,40,121,… or , and is Sloane’s A003462.
• , is given by 0,1,5,31,85,341,… or , and is Sloane’s A002450.

The general formula is .

*
* *

The cases with , and can be implemented very efficiently depending on the type of processor you are using. Of course, multiplies by powers of two can be replaced by left shifts. On Intel processors, the following two functions:

inline int left_child(int x) { return 2*x+1; }
inline int right_child(int x) { return 2*x+2; }

Can each be replaced by a single lea instruction. Assuming the parameter value is passed through eax, left_child should compile to lea eax,2*eax+1. Since the normal calling convention for Intel is to return integer types through eax, we’re done.

*
* *

If you think this addressing scheme is way cool, you’ll find even more interesting that the scheme dates from way back [1]. Although Williams considers it only in terms of a binary heap (for heap sort) and that expresses the addressing relations only in terms of the address of the parent; one can understand through that very terse paper (a page and a few lines) that the addressing can be generalized. Williams’ paper is the earliest reference I could find on the addressing scheme. However, I am not sure that it is the original paper; surely the 1964 C.ACM report is based on earlier work?

The Association of Computing Machinery (ACM), the first society in computing, re-launched its flagship magazine “Communications” today with July 2008 edition.

For many of us used to CACM (the way Communications is called) since 70’s, it is indeed heartening to see the transformation in

• Content

• Layout

• Design

And

• Branding

It is refreshingly pleasing to the eyes; there is depth in content; consistency in style; and, clarity in addressing the different stake holders.

I am sure CACM over the next one year will claim its exalted position within computing literature.

La semana pasada, unos días antes de irme a Toulouse, estuve echando un vistazo al número de abril de la revista científica Communications of the ACM, una publicación periódica de la ACM. Lo interesante es que en portada de dicho número (volume 51, number 4) encontramos, curiosamente, la seguridad como tema principal, con un artículo de Ryan West (investigador de Dell) titulado “The psychology of scurity“, que viene acompañado del más curioso aún subtítulo “Why do users make bad decisions?“.

El artículo analiza justamente lo que su subtítulo deja adivinar: ciertos aspectos que hacen a los usuarios correr riesgos de seguridad, en la mayoría de los casos innecesarios. Desde aspectos psicológicos, como la falsa sensación de seguridad, hasta aspectos de diseño, como el formato de las ventanas emergentes de alerta, y pasando por problemas técnicos, como la abstracción del término “seguridad”; el autor realiza un brillante análisis de la situación actual de la seguridad a nivel de usuario, planteando ciertos escenarios como ejemplo.

Pero no es el único artículo relacionado con la seguridad en este número, pues también encontramos un artículo de Hal Berghel titulado “Faith-Based Security“, más brillante aún si cabe que el anterior, a pesar de no ser el artículo central de la revista. En este texto, el autor realiza una ácida crítica de los sistemas que denomina de “seguridad basada en la fé”, particularmente de la filosofía de security through obscurity. Analizando ejemplos como el cifrado WEP, el desbordamiento de buffer de la extensión ISAPI de Windows [1], o la famosa y reciente vulnerabilidad del cifrado MIFARE en chips RFID (de la cual hablé aquí); Berghel rompe una lanza en favor del full disclosure, aportando argumentos sobre su idoneidad en el desarrollo de la seguridad informática.

Hay un par de artículos más que me interesan, y que aún no he tenido tiempo de leer, titulados “Disk is the new RAM” y “The business of Open Source” respectivamente. A ver cuándo les puedo echar un ojo.

En cualquier caso, siempre es una agradable sorpresa ver que en publicaciones serias -más aún si tienen tanta tradición como la que comento- la seguridad informática tiene cabida, y más aún si el tema es tratado de una forma tan coherente, alejándose de intereses comerciales y la larga sombra de determinadas compañías…