Remembering the Future

In line with Christensen's theory, I would assert that every "pure software" company that has had large-scale success first offered their customers enhanced productivity in the form of packaged proprietary software, followed later by a redefinition of that software as a platform to be used by customers for rapid customization and their extensibility needs. (Such platforms, besides solving customer problems, also have the salutary effect of ensnaring those same customers and extenders within their "ecosystems," slowly raising switching costs over time. Think of customers and small-scale participants in these ecosystems as boiled frogs...)

For many years programmers have dreamed of building systems from a library of reusable software components together with a little new code. The closest we've come is Unix commands connected by pipes. I'll discuss the fundamental reasons why software components of this kind haven't worked in the past and are unlikely to work in the future. Then I'll explain how the dream has come true in spite of this failure, and why most people haven't noticed.

The Importance of Performance Previous attempts to implement Python and other highly dynamic languages for the CLR have resulted in systems with extremely poor performance. Performance so bad that they were considered unusable.

"The speed of the current system is so low as to render the current implementation useless for anything beyond demonstration purposes.“ – ActiveState’s report on Python for .NET

"The CLI is, by design, not friendly to dynamic languages. Prototypes were built, but ran way too slowly."– InfoWorld, Aug. 2003

There are many other such anecdotal remarks on the web claiming that the CLR is a poor platform for dynamic languages. These results were surprising to me. The CLR is supposed to be a superset of the functionality in a JVM. The JVM can host a number of dynamic languages with very good performance. Jython stands as the clearest proof of this with performance close to the native C implementation of Python (CPython). I wanted to pinpoint the fatal flaw in the design of the CLR that made it so bad at implementing dynamic languages. My plan was to write a short pithy article called, "Why .NET is a terrible platform for dynamic languages".

Unfortunately, as I carried out my experiments I found the CLR to be a surprisingly good target for dynamic languages, or at least for the highly dynamic specific case of Python. This was unfortunate because it meant that instead of writing a short pithy paper I had to build a full Python implementation for this new platform to see if there would be any hidden traps along the way. Because performance is such a dominant question for Python on the CLR, the rest of this paper focuses entirely on performance issues and measurements.

One of the things I hate about the joy of postbacks is losing my scroll position.  On a page that's a bit longer than the window, if I have an auto-postback combobox (for example), the user selects an item, the page posts back, and poof! they're back at the top of the page.

On a corporate intranet the post back is nice and fast, and many times the user has no clue that it happened....  Except for the fact that the page just "jumped" back to the top.

Because of this I (as many people) write my controls to re-position, or I have page logic to re-position after a postback. There are articles on CodeProject with controls for keeping the scroll position,   one on DotNetJunkies that isn't quite so pre-packaged, but still good, and several tutorials.  The problem then is that the behavior is coded in everywhere, or the control must be included on each page, or the page must be derived from something other than the Page class, or something else..  I wanted a fire and forget solution.

So here's what I created late last night to un-vex myself -- an HTTPModule that adds scroll position retention across postbacks to all pages.  It's implemented as a filter that adds javascript to the pages after they are output.  I've tested it only on IE 6, as that's the browser my client site's intranet uses.  

The nice thing about this (to me) is that three lines in your web.config instantly gives you scroll position retention across postbacks on every page in your application.  No muss, and not a whole lot of fuss.

This is an interesting overview of RSS resouces and answers to basic questions

Duncan Mackenzie describes how to build a tool that uses the Background Intelligent Transfer Service features of Microsoft Windows XP to download large files over slow or intermittent links.

Furthermore you've the possibility to open the WinFS database in SQL-Server: the database-file lives in the folder c:\windows\system32\winfs\data\catalog.mdf.
. . .
When you then look to the extracted mapping file and the database you can see that each <type>-element is mapped to a database table - cool isn't it? From the default namespace of the mapping file (http://www.microsoft.com/ObjectSpaces-v1) you can see that MS is using a version of object spaces for creating the mapping between the CLR types and the database tables.

In WinFS we have an item table and a relationship table. The item table has an ItemId column. The relationship table has SourceItemId and TargetItemId columns. At the SQL level, when querying for related items you join through the relationship table.

Summary: Tom Rizzo launches his new column with an overview of why the new "Longhorn" storage subsystem (code-named "WinFS") is needed, what WinFS promises to do to help solve our data-overload problems, and what his column promises to deliver in the coming months. (5 printed pages)

Welcome to my new column, The WinFS Files! This column is aimed at helping you, the developer, understand more about the forthcoming technological innovations in the next release of Microsoft® Windows® code-named "Longhorn," specifically the revolutionary new file system code-named "WinFS." As this column progresses, we'll take a look at the data model, feature-set, and programming paradigms that characterize WinFS. This initial column will give you a broad overview of what is new in WinFS and how you can get started learning about and understanding this new technology.

Why WinFS?

In the technology industry, there is a growing "perfect storm"—a combination of trends and technologies that will allow the next quantum leap in the way you develop and work with your information. This perfect storm is comprised of three forces joining together: hardware advancements, leaps in the amount of digitally born data, and the explosion of schemas and standards in information management.

See: Building bug-free O-O software:

The notion of Design by Contract is central in the systematic approach to object-oriented software construction, as embodied in the Eiffel method. This article presents the key ideas.

In our opinion the techniques outlined below are as important as the rest of object technology -- as important as classes, objects, inheritance, polymorphism and dynamic binding, which they complement -- although only a subset of the O-O literature has so far devoted its attention to it. (See the references at the end of this paper.)

To go beyond the theoretical understanding provided by this paper and experience the practical power of its ideas, take a look at the Eiffel environment, which is their direct implementation.

NOTE: For a sobering reminder of the practical consequences of not applying the principles described in this article, see Put it in the Contract: The Lessons of Ariane, originally published in IEEE Computer and now available in these Web pages too.

There are three primary situations when developers need to consider what APIs to use for representing XML. The situations and guidelines are briefly described below:

• Classes with fields or properties that hold XML: If a class has a field or property that is an XML document or fragment, it should provide mechanisms for manipulating the property as both a string and as an XmlReader.
• Methods that accept XML input or return XML as output: Methods that accept or return XML should favor returning XmlReader or XPathNavigator unless the user is expected to be able to edit the XML data, in which case XmlDocument should be used.
• Converting an object to XML: If an object wants to provide an XML representation of itself for serialization purposes, then it should use the XmlWriter if it needs more control of the XML serialization process than what is provided by the XmlSerializer. If the object wants to provide an XML representation of itself that enables it to participate fully as a member of the XML world, such as allow XPath queries or XSLT transformations over the object, then it should implement the IXPathNavigable interface.

Nearly every element in Atom is already contained in one of the DC specs. I took the time to compare the Atom elements with their DC equivalents and found something quite interesting: when you remove the overlap with Dublin Core what's left is pure syndication.

The only elements that don't have obvious conterparts in DC are those that deal with the syndication aspect of Atom, and to be honest there aren't many of them: atom:feed, atom:info, atom:entry, atom:link, atom:content. So my question is this: why isn't Atom defining a Syndication Element Set as a complement to the Dublin Core Element Set? Why duplicate all that effort when the Dublin Core people have been over the issues again and again for nine years? There are many people that I know are intimately familiar with Dublin Core who are involved in the syntax effort so why aren't these elements being used. Is it NIH or something else?

These structures are changed by applying transformations like Web Services and XSLT instead of atom numeric and logic operations. While traditional programming operated on programming structures at a local level (changing specific variable bindings) in the new model, data structures are transformed as a whole. A service takes in a coherent structure and returns a coherent structure. The holistic coherence of that structure can be checked before it is accepted for processing by the service, and after it has been transformed.

These transformations also have identity, and can therefore be represented within a data structure. This allows an evolving resource (representation) to contain within itself, the actions that allow it to continue to be transformed.

A data structure may contain links to many alternative services for transformation. This requires that either a human interpret the data to select an action, or that there is some method for automating the evaluation and selection of an action/transformation. In order to be compared, the evaluation of these alternative actions must once again be represented as numeric values that can be given an order (preference).

In applied mathematics, these kind of temporal credit assignment problems are solved through the use of dynamic programming. In computer science, these topics have been studied in research on artificial life and computational models of evolution and reinforcement learning.

See also:
Christopher Alexander on programming
social software: representing relationships, part 3
The meaning of SOA
Workflow, RSS and business documents
Conceptions of a Global Brain: a historical review
The Philosophical Basis of Knowledge Representation and the Web

A graph, like a tree, is a collection of nodes and edges, but has no rules dictating the connection among the nodes. In this fifth part of the article series, we'll learn all about graphs, one of the most versatile data structures.

Onfolio Inc. launched their namesake product Onfolio, helping to shape and define a new and important category in Internet software -- search information management. 

Onfolio helps Internet users to easily collect, organize and share their research.  The product is built around the idea that 'search' has become the most common Internet activity, yet end-users have had virtually no good tools to help them manage and share all the "micro-content" that they find on the Internet.

The product tightly integrates into Internet Explorer, Microsoft Office and the Windows desktop, enabling users to capture fragments of content from web pages, email, RSS feeds, and their desktop.  In essence, users create content 'collections', personal databases of micro-content that can be organized and searched locally, but then re-composed into reports that can be shared via email, posted as websites, and published as RSS feeds.

Forbes.com characterizes it's essential role:  "Onfolio faces head-on the problem of information overload, giving Internet users ways to capture and reuse the many tidbits they come across in everyday Internet use."

The uses of the product touch anyone who seriously uses the Web, whether for personal or professional use.  The Onfolio website has some great usage examples to help spark your imagination.

Onfolio was founded by my brother J.J. Allaire, and also led by Allaire co-founders Adam Berrey and Charles Teague.  They've done a great job creating an exceptionally useful product that will help all of us become more productive users of information on the Internet.

I can personally attest that Onfolio has transformed my relationship with content on the Internet -- I am more in control of the surging amount of micro-content that floods websites, email, RSS feeds and beyond.  Thanks guys!

This working document distills "information axioms" for emerging policy networks. We culled these information axioms from a variety of analysts whose work examines primarily - but not wholly - emerging commercial information networks on the Internet. These "axioms" do not necessarily apply to non-profits, or true communities, but rather, are to serve as a starting point in understanding the role of information and information technologies in the policy process. We intend to produce a similar set of axioms for the way information is used by contending policy currents in information battles in US foreign policy decisionmaking. Please submit your comments, suggestions, or own axioms below to contribute to this process.

* Click on each axiom below for contents. Comments can be posted from each axiom page.

Download Entire Document: Microsoft Word | PDF

---

axiom 1 - metcalf's law axiom 2 - early entrants win the field axiom 3 - significance precedes momentum axiom 4 - standards as power axiom 5 - producer and consumer utility axiom 6 - gatekeepers, intermediaries, and the attention deficit axiom 7 - positive feedback loops axiom 8 - differentiation of products and pricing axiom 9 - switching costs and lock-in axiom 10 - free information: cooperation in a competitive environment bibliography

To clarify, by better browser integration I meant mostly integration with the de.licio.us functionality.  For example, here are some of the things I would like to see:

·         Access to my shared bookmarks from directly in the favorites menu of IE; and adding to favorites from IE automatically adds to de.licio.us (I’m aware of the bookmarklet)

·         When browsing a page, any hyperlinks in the page which are also entries in your friends’ favorites lists would be emphasized with stronger or larger typeface

·         When browsing a page, some subtle UI cue would be given for pages that are in your friends’ favorites lists

·         When visiting a page that is in your favorites list, you could check a toolbar button to make the page visible to friends only, everyone, or nobody

·         When visiting a page which appears in other people’s favorites, provide a way to get at recommendations “your friends who liked this page also liked these other pages”, or “your friends recommend these pages instead of the one you are visiting”

I honestly think the idea becomes much more compelling when you share all page visits, and not just favorites.  You can cluster, find people who have similar tastes or even people who have opposite tastes.  And the “trace paths” could be much more useful; shrinking font on hyperlinks that are not often clicked, and increasing where people often follow.

What are smart clients and why do they matter?
So, 'smart client' is a new term, or a relatively new term for developing clients on the .NET framework that exhibit a number of properties or comply with a number of tenets. And again, with any of these new marketing or terms, it's really about what you perceive as being a smart client, as for the definition.

So my definition of a smart client falls into five categories. A smart client for me must be connected to Web services. It must utilize the local resources on the actual machine. So, things like multimedia or maybe Office, if it's installed. It must expose the abilities of the device. So, if I'm running on a PC, I don't want my application to just run in a single window, I want it to maybe open multiple windows and maybe really leverage what I have on the desktop and integrate with Explorer as well. Likewise, if I'm on a pocket device or a Smart Phone, I want to really expose some of the capabilities there as well.

Number four is kind of a 'must work offline' or that's certainly one of the tenets we're really pushing. So, if I'm at the airport and I'm using the client, I can then get onto the airplane and it's going to work in some limited fashion, although in an offline state.

And then, finally, it must be able to have some way of being auto-updated or auto-deployed. So there're certain patterns and certain techniques that we're looking at to say: Well, how when the actual client is deployed to the desktop, can we then update it, or can we then basically deliver new versions of the application without causing this deployment nightmare.

So, what's the role of Office in the smart client platform? So, personally I see Office as really being a foundation of being a smart client. So, Office itself, in stand alone mode can do some smart client functionality. But in itself it may not be categorized as a smart client executable. So what we see is a number of applications and utilities that are built using Windows Forms, they're consuming Web services, but then they're using the local resources of Office as they exist today.

So, one way to do that is to use the Visual Studio tools for Office. And what this does is it provides a managed API both for Word and Excel in the current version. And this is great because what I could do then is I can build my applications in new Windows Forms, I can add support for offline, I can connect to Web services, but the type of data I'm actually dealing with can really be native to Office. So, maybe I'm actually attaching that assembly to a Word document/literal, or maybe I'm integrating some functionality within Excel to provide functionality that, otherwise, I would have had to write myself.

And I think for customers that are actually looking at the space, they see the value of Office as being there in the enterprise; it's installed on pretty much everyone’s desktop. And really, they're looking for a way to leverage and make use of the benefits of Office within this smart client paradigm.

GigaSpaces provides Microsoft .NET , C++ , Java , J2EE & Web services Interfaces.

With the evolution of Internet and the information technologies, working with big volumes of information has increasingly become more common. Hard disks represent the first half of the storage for personal information. They are commonly used to store personal contacts, work documents, etc. These information items usually keep certain relationship levels among them. So, when you work with a large number of these items, it is very important to organize them and provide a flexible search mechanism based on their properties and content. To address these problems, the recent Microsoft® Windows code named “Longhorn” features a new storage platform: WINFS.

I read a lot of Java related blogs and a lot of MS related blogs, but very few of the Java blogs are by Sun folks. So I followed Simon's link to Sun bloggers, eager to stock up on the good content that I've been missing out on. When I got there, I discovered that the list isn't very long, although it includes lots of Sun luminaries, and that about half of the blogs haven't been updated in 2004. Color me disappointed. It's hard to claim quality when quantity is AWOL. . .

Even after thinking about it, I still feel that the .NET blogging community is a smaller appendage to the larger MS blogging community, while the Java blogging community is a big place that the small Sun blogging community is trying to break into. What I mean is this: If I'm looking for thought leadership from the community, in the Java community, I'm looking towards the non Sun bloggers -- these are the folks doing AOP, Groovy, SGen, Prevalence, WebWork, etc. This shows the rich ecosystem that has grown up around Java. If I look at the .NET community, I pretty much look for the MS bloggers. There are some leaders outside of MS, but pretty much the thought leadership resides with folks inside the "big house". From where I sit, this is an accurate characterization of the .NET and Java ecosystems. In the end, the two companies have to decide not only that they want to foster communities, but what kind of community they want.

Let's not confuse cause and effect here. There used to be plenty of .Net bloggers who didn't work for Microsoft. I still haven't forgiven Microsoft for what they did to Peter Drayton.

Building dynamic data-driven Web applications with Microsoft ASP.NET and the Microsoft SQL Server 2000 Desktop Engine (MSDE 2000) is easy. When it comes to scalability however, MSDE 2000 has specific limitations compared to the full-blown versions of SQL Server 2000. One key limitation is that MSDE 2000 contains a Workload Governor that throttles the number of concurrent operations the database engine can perform. The solution is pretty simple: adjust the size of the default connection pool used by ADO.NET by adjusting your ASP.NET application's database connection string.

Sounds like Sun's been bitten by the RSS bug. Like Microsoft already has done, Sun is looking to expose its developer information as RSS feeds. No big surprise there. But Sun also is contemplating adding an RSS aggregator to the Java Desktop System, it seems. Microsoft is working to do the same with Longhorn client. But maybe Redmond will decide that it needs to do so sooner (perhaps via XP Reloaded, whatever form that takes), now that Sun is making RSS noise? We shall see.

I read with interest Edd's thoughts on XAML and a new UI for GNOME. I have been doing some small XAML tests recently, and it is a very easy markup to generate. As I mentioned before the issue with XAML is that it will be very attractive to developers to move from HTML to XAML, as it provides more control, more widgetry and is an extensible system.

The future of Linux on the desktop is in fact on the line: if enterprise developers and IT developers fall in love with Xaml for building their in-house applications it will marginalize again Linux on the desktop.

There are two views of how to solve this problem. The Nat Friedman view of building a matching system in the meantime: leveraging our existing technologies, or the Miggy-view, which is lets implement the Avalon/XAML API. I think we should pursue both paths.

First, be extremely careful about privacy issues. . .

If possible, find some other way to call the connections between people "friends" -- maybe even use a unique trademarkable term. There is some power in the emotions behind the word friends that helps with the virus-like nature of social networking software, but I think in the long term it is a bad idea. . .

Someone's profile needs to express the richness of who they are -- it also needs to change and grow and flow over time, so make it easy for people to annotate and grow over time. . .

Be very careful of the design of rating systems and reputation systems. They are extremely difficult to design well, as they too often can be gamed, or fall into reciprocity such that they are meaningless. . .

Figure out how to use RSS everywhere for input and output. . .Combine all the above with good innovative RSS and optionally Atom. . . Do a great job for those who don't use RSS and those APIs to use email instead

Offering intentional groups . . . Better ways to organize groups of groups. . . Lots of group management support. . .

Most people try to solve problems in a step by step "do this and then do that" style. The declarative approach of the prolog gurus is alien to joe sixpack. Combine this fact with the fact that to solve any real-world problems in prolog involves interfacing with third party C and C++ libraries in a non-declarative fashion, is it any wonder that most programming gurus (Kent Beck for example) recommend Smalltalk-80 ?

-- "Never say what you can grunt. Never grunt what you can wink. Never wink what you can nod, never nod what you can shrug, and don't shrug when it ain't necessary" -Earl Long