coComment Roundup

Google search results for "cocomment":

• after 4 days, from virtually zero to 200'000 
  
• after a week there are now about 400'000 search results

9.2.2006, 11:23

Track your comments

Track your comments throughout the blogosphere and keep the conversations flowing... coComment is out of the bag.

Sketching image queries and reinventing email

A first sneak peek at the things we can expect from System One in 2006: Retrievr lets you find flickr images by drawing rough sketches of them.

" This article is not intended as a proposal for a replacement for email. [...] Nevertheless, in understanding how the move to REST improves email, you will hopefully come to see how moving your own web services to it would improve them ."

In other news... 

Subversion hits 1.3.0 and brings us path-based authorization for svnserve.

In case you've been looking for it: Venkman for Firefox 1.5

And one more puzzle piece for building Mocha heaven: Banteng - leveraging GCJ and Rhino to build cross-platform native applications in Javascript.

3.1.2006, 9:23

ECMAScript - The Switzerland of development environments

" When you already know what your types should be, [...], declare them. When you don't, don't. One language, two styles, complementary benefits. Good idea!"

29.12.2005, 13:45

I love E4X

As a reality check of my proposal for skins in Helma 2 , I so far came up with the following prototype. The idea seems to work quite nicely already with current builds of Helma 2. I thought E4X could make implementing these kinds of mocha objects very easy, but I was surprised that it really turned out that way in practice.

function handle_get() {
    // first prototype for the next incarnation of mocha objects
    
    // the render function, providing the magic
    var render = function(view) {
        // loop
        var toLoop = view..*.(@loop.toSource() != '<></>');
        for (var item in toLoop) {
            var dataName = toLoop[item].@loop.toString();
            delete toLoop[item].@loop;
            var data = eval(dataName);
            var stamp = toLoop[item].toString();
            for (var i in data) {
                var stencil = stamp.replace(
                    eval("/%% "+dataName+"\\$\\.(.+) %%/g"),
                    '{ '+dataName+'['+i+'].$1 }'
                );
                stencil = stencil.replace(
                    eval('/"'+dataName+'\\$/g'),
                    '"'+dataName+'['+i+']'
                );
                stencil = stencil.replace(
                    eval('/"%% (.*)\\$'+dataName+'(.*) %%"/g'),
                    '{ $1'+i+'$2 }'
                );
                toLoop.parent().insertChildBefore(
                    toLoop[item],
                    eval(stencil)
                );
            }
            delete toLoop[item].parent().*[toLoop[item].childIndex()];
        }
       
        // lookup
        var toLookup = view..*.(@lookup.toSource() != '<></>');
        for (var item in toLookup) {
            delete toLookup[item].@lookup;
            var lookedup = '('+toLookup[item].children()[0]+')';
            toLookup[item].setChildren(lookedup);
        }
   
        // check
        var toCheck = view..*.(@check.toSource() != '<></>');
        for (var item in toCheck) {
            if (eval(toCheck[item].@check.toString()))
                delete toCheck[item].@check;
            else
                toCheck[item] = '';
        }
        return view;
    }
   
    // an example skin
    var myview = <table border="1">
        <tr check="topics">
            <th lookup="true">Topic Name</th>
            <th lookup="true">Comment Count</th>
        </tr>
        <tr loop="topics" class="%% 'rowcolor'+ ($topics % 2) %%">
            <td>%% topics$.name %%</td>
            <td check="topics$.count == 0" lookup="true">
                No comments yet</td>
            <td check="topics$.count == 1" lookup="true">
                %% topics$.count %% comment</td>
            <td check="topics$.count > 1" lookup="true">
                %% topics$.count %% comments</td>
        </tr>
        <tr check="!topics">
            <td colspan="2" align="center" lookup="true">
                This list is empty</td>
        </tr>
    </table>;
   
    // the example data
    var topics = [
        {name : 'Peter', count : 0},
        {name : 'Wolf', count : 2},
        {name : 'John', count : 1},
        {name : 'Andy', count : 8}
    ];
   
    // rendering the list
    var listtable = render(myview.copy());

    // rendering the empty table
    topics = null;
    var emptytable = render(myview.copy());
   
    // assembling the page
    var page = <html><body>{ listtable }<hr/>{ emptytable }</body></html>;
   
    // writing the page source to the reponse buffer
    res.contentType = "text/html";
    res.write(page.toSource());
}

Resulting in the following output:

Tutorial D, Industrial D and the relational model

From this interview with Chris Date :

[...] But the trouble with the relational model is, it's never been implemented--at least, not in commercial form, not properly, and certainly not fully. So while it's true that there have been a couple of developments in the marketplace over the past few years that I do quite like, I like them primarily because I see them as attempts to implement pieces of the relational model that should have been implemented years ago but weren't. I refer here to (a) "business rules" and (b) "object/relational DBMSs." I'll take them one at a time.

• Business rules: Business rule systems are a good idea, but they certainly aren't a new idea. Without going into a lot of detail, business rule systems can be seen as systems that attempt to implement the integrity piece of the relational model (which today's mainstream SQL products still--over 35 years after the model was first described!--so signally fail to do).
• Object/relational DBMSs: To a first approximation, "object/relational" just means the domains over which relations are defined can be of arbitrary complexity. As a consequence, we can have attributes of relations--or columns of tables, if you prefer--that contain geometric points, or polygons, or X rays, or XML documents, or fingerprints, or arrays, or lists, or relations, or any other kinds of values you can think of. But this idea too was always part of the relational model! The idea that the relational model could handle only rather simple kinds of data (like numbers, and strings, and dates, and times) is a huge misconception, and always was. In fact, the term object/relational, as such, is just a piece of marketing hype ... As far as I'm concerned, an object/relational system done right would simply be a relational system done right, nothing more and nothing less.

[...] The next thing I want to say is that, while the relational model is certainly the foundation for "doing databases right," it's only the foundation. There are various ways we can build on top of the relational model, and various attempts have been made to do such a thing over the past 25 years or so. Here are a couple of examples:

• Higher-level interfaces: It was never the intention that every user should have to wrestle with the complexities of something like SQL (or even the complexities, such as they are, of the relational algebra). I always rather liked the visual interfaces provided by Query-By-Example and the "visual programming" front-ends to Ingres, for instance. And there are many other attractive front-ends that simplify the business of building applications on top of a relational (or at least SQL) DBMS. 4GLs too can be regarded as a higher-level interface--but I was never very impressed by 4GLs as such, in part because they never seemed to be precisely defined anywhere; the idea might have been OK, but without a formal definition of the semantics of the language some very expensive mistakes can be (and were) made. Natural-language systems are another example; I still have an open mind about these, but I don't think anyone could claim they've been a huge success as yet.
• Special-purpose applications: I think the right way to view things like OLAP and data mining is as special-purpose applications that run on top of the DBMS. I mean, I don't think these things should be part of the core DBMS (I could be wrong). Either way, however, I do want to complain about the CUBE stuff in SQL, which takes one of the worst aspects of SQL--its support for nulls--and "exploits" it to make it even worse. But that's a particular hobbyhorse of mine ... I think I'd better stop right here.

19.12.2005, 0:01
 

Stop bashing Java

Jürg, making the case for Java beyond J2EE :

"...there were alternatives around since years (e.g. Helma , which is surprisingly similar to Rails in a few fields), and often the people who now blame J2EE for not having been efficient were simply to lazy to really look for alternatives earlier on."

"I think it might be time to stop bashing Java and enjoy the fact that there are actually ways of working with it or any language available in its growing little universe that are enjoyable, not bound to Sun licenses, very flexible, fast and resource-saving."

18.12.2005, 20:16

>>> E4X Mocha Objects