Posts with keyword: javascript


                    Dave Winer has been developing applications that support users owning their own data. His latest is a blog page rendering system he calls MyWord.io.
                    Continue reading...

                    Introducing Forever and Personal Cloud Application Architectures

                    Personal clouds give rise to a brand new application architecture that gives people more control over their data and breaks down data silos to provide greater network effects. We've built an evergreen contact application called Forever that demonstrates this new architecture to developers and provides people with an online contact database that is never stale.
                    Continue reading...

                    KBlog: Making the Back Button Work

                    Friday, I posted a long blog article that discussed using KRL to create a simple blogging application. the application writes multiple pages, manages a navigation bar, and allows new posts. (Try it here.) One problem with the implementation is that because it paints the entire app in a single page (sometimes called a single page interface or SPI), the back and forward buttons don't work. The problem is that the browser doesn't know there's a new page and put it on the history unless the URL changes. The back and forward buttons are just indexes on the browser history.
                    Continue reading...

                    Why Use the Kynetx Rule Language Instead of Javascript?

                    Last Friday I blogged about using Kynetx to put my latest tweet on my blog. Joseph Scott asked "Why would this be better than just using Javascript plus the Twitter API to show your last tweet?" The answer is a little longer than I wanted to put in a comment, so here goes. KRL has a number of advantages over Javascript talking to the Twitter API: KRL, the Kynetx Rule Language, provides a closer abstraction to the task than Javascript does as a general purpose language. This is, of course, something that could be subject to debate--if you're already
                    Continue reading...

                    jQuery, Monads, and Functional Programming

                    I tweeted this over the weekend, but it deserves a bigger mention than that. Patrick Thomson has written a wonderful description of why jQuery is a monad including a discussion of cautious computation and state transformations. No need to know monads or jQuery (although an interest in one will help you appreciate the other). As Patrick explains nicely, jQuery is monadic in that is meets all three requirements of a monad. A monad is a concept from category theory. A type is a monad if it meets three requirements Monads wrap themselves around other data types
                    Continue reading...

                    Worlds: Tabs for Programming

                    Via Lambda the Ultimate a pointer to a paper by Alessandro Warth and Alan Kay (PDF) called "Worlds: Controlling the Scope of Side Effects". I didn't get as much out of reading the abstract as I did from the opening paragraphs of the intro: Suppose that, while browsing the web, you get to a page that has multiple links and it is not clear which one (if any) will lead to the information you're looking for. Maybe the desired information is just one or two clicks away, in which case it makes sense to click on a link, and
                    Continue reading...

                    Sam Ruby on jQuery

                    Despite an aversion to frameworks, Sam Ruby is trying out jQuery and generally seems to like what he sees. He says "The net effect of all of this is that you can 'write less and do more', as promised."
                    Continue reading...

                    Javascript Thunks

                    I love how Javascript libraries like JQuery require people to use thunks all over the place: $(document).ready(function() { $("#orderedlist li:last").hover(function() { $(this).addClass("green"); },function(){ $(this).removeClass("green"); }); }); The functions without parameters are called thunks and their purpose is to delay the evaluation of the code in argument positions, circumventing standard applicative order evaluation. Here's hoping that future languages--even future versions of Javascript--take this need into account and add real linguistic features for delayed evaluation. Oh wait--Lisp already does and it's only 50 years old.
                    Continue reading...

                    Prototype Framework is a Javascript Extension, Not Just a Library

                    I recently ran into a problem with Prototype (the Javascript framework) that exposes a big difference between the design philosophy of Prototype and other frameworks like JQuery. Consider this code: var aryOmnDiv = [ 'header_tracking', 'left_nav_tracking', 'footer', 'homepagecategories', 'subcats', 'bread_crumb', 'subcat_wrapper', 'prod_group_wrapper']; //container divs for(var outside_i in aryOmnDiv) { var divname = aryOmnDiv[outside_i]; var div = $(divname); if(div) { \tvar anchors = div.getElementsByTagName('a'); } } Running this with Prototype installed produces and error that says "getElementsByTagName is not defined." The culprit is that the code is using a for...in loop as a shortcut for looping through the array. The
                    Continue reading...

                    Tyler Close: Using Promises to Orchestrate Web Interactions

                    Tyler Close answers questions after his talk(click to enlarge) Tyler Close of Waterken fame presented a way of using promises to produce succinct JavaScript (and Java) code for doing multiple asynchronous requests with a Web server. The idea of promises in asynchronous systems was developed by Barbara Liskov in the late 80's. Tyler has a tutorial online. I also found this description from Brian Lothar of Web calculus which discusses promises in that context. Very interesting stuff. I think this was my favorite presentation of WWW2008.
                    Continue reading...

                    ParenScript: A Lispy JavaScript Generator

                    Feedback on my interview with Bruce Johnson on the Google Web Toolkit led to ParenScript, a little language for Lisp that generates JavaScript. From the intro: ParenScript is a small Lispy language that can be compiled to JavaScript. It also comes with client-side HTML and CSS generation libraries. This approach simplifies the development of web applications by enabling all components of the application to be written in Lisp, so that HTML, CSS and JavaScript code can all be generated with the full power of Lisp and its macros. At the same time, ParenScript strives to produce maximally readable JavaScript
                    Continue reading...

                    Google Web Toolkit

                    I just posted my interview with Bruce Johnson on the Google Web Toolkit. This was a fun interview and I learned a lot. GWT allows you to write AJAX applications in Java that then gets compiled to Javascript.
                    Continue reading...

                    Reading News on the iPhone

                    Before the iPhone was released last week, news of an RSS reader for the iPhone started showing up. If you go to http://reader.mac.com/ with a browser, you see the message "This application can only be viewed using the iPhone." Visting it with an iPhone just shows the message "type an RSS URL into your browser" or something like that. I thought "that's lame--they built a whole Web site to tell me to type a URL into by toolbar?" But when you do, the browser automatically redirects to reader.mac.com and displays the RSS as a nice iPhone formated screen. It's
                    Continue reading...

                    First iPhone App

                    Want a glimpse of the first iPhone app in the wild? OneTrip is a shopping list application that is built with the iPhone's form factor and multi-touch screen in mind, but will run in Safari on any platform (and apparently Firefox as well). one thing I noticed when I played around with it is that there's no log in. That makes it simple, and cookies are good enough to keep your list around from visit to visit. But the power of a Web-based application lies partially in it's ubiquity. I want to be able to maintain my list on
                    Continue reading...


                    Paul Figgiani sent me a link to Schmedley. It's like the OS X dashboard inside the browser. The fact that you can do this kind of thing in a browser still amazes me. Update: I wrote more about Schmedley at BTL this afternoon.
                    Continue reading...

                    The Most Important Language in 2006: JavaScript

                    You gotta love Steve Yegge's blog. One of his latest posts is called Dreaming in a Browser Swamp. Steve's style is to write infrequent, long posts, but they are always worth the wait and the read. "Browser Swamp" makes the outrageous claim that JavaScript is the most important language in the world today. A claim that surely going to get some argument (language wars are so much fun) but one which is grounded in some solid rationale. Note that Steve didn't say that it's the best language, only that it's the most important.
                    Continue reading...

                    Knowing the User's Every Move

                    I sat through Richard Atterer's talk on User Activity Tracking for Website Usability Evaluation and Implicit Interaction. (See the paper.) The problem is that putting code on the client to track user actions is invasive and users aren't likely to put up with it. On the other hand, putting the code on the server misses JavaScript actions that don't result in server requests. Their answer was to use a rewriting proxy called UsaProxy that rewrites any page you request to make sure their tracking JavaScript is included. Very clever and related to some other things I've seen for modifying
                    Continue reading...

                    Rails and Ajax for Page Application Development (ETech 2006 Tutorial)

                    I'm in David Heinemeier Hansson's tutorial on Beneath-the-Page Application Development with Rails. His Rails tutorial from last summer remains one of my most viewed blog entries. He starts out noting that AJAX is the most important innovation for the Web in years. But JavaScripting the DOM still sucks...a lot. JavaScripting the DOM is incompatible with how regular programmers think about programming. Part of the problem is the sorry state of browser. One line of change can lead to hours of regressions because of browser incompatibilities. Then there's the browser underworld (all the old, out of date browsers that are
                    Continue reading...

                    Introduction to JavaScript (ETech 2006 Tutorial)

                    This morning I'm in the A (Re-)Introduction to JavaScript tutorial taught be Simon Willison. Simon recommends Javascript: The Definative Guide by David Flanagan as one of the few Javascript references that's worthwhile. He hasn't found a good reference on the Web. Brendan Eich invented JavaScript in 1995. The ECMA standard went through only 3 revisions with the last one in 1998. Good news: the language is stable. Bad news: there's lots of codified warts. Javascript avoids I/O, so it's not quite a general purpose language: it has to be embedded in a host environment that supplies this. In the
                    Continue reading...

                    ETech Tutorials

                    I'm at ETech, just waiting for the the first tutorial to begin. I'm signed up for two today. This morning I'm going to A (Re-)Introduction to JavaScript taught be Simon Willison. This afternoon, I'm going to Beneath-the-Page Application Development with Rails with David Heinemeier Hansson. His Rails tutorial from last summer remains one of my most viewed blog entries. I'll post notes, so follow along.
                    Continue reading...

                    Thin is In

                    IFlyAKite Desktop in Javascript I'm not sure what the purpose of this site is, but it's cool. If the purpose is to show just how far Javascript can be pushed to create a rich-client feel inside a browser, then I'd say they've succeeded. Apple will probably try to shut this down, but they ought to leave it up as a monument to dedication.
                    Continue reading...