Dave Johnson

June 6th, 2006

It was only a matter of time really. Google has just released some information (no ability to actually use it yet) about their latest free product offering that is an online collaborative spreadsheet. I wonder if the writely folks had anything to do with this?

I think that this can only be a good thing for our company as we are planning an online spreadsheet product for use behind the firewall.

Technorati Tags: ajax web2.0 google spreadsheet

Posted in Web2.0, AJAX | No Comments »

June 1st, 2006

We have been uber busy writing the old book and getting lots of JavaScript written these days so blogging has been on the backburner a bit

I did get a chance to finally take a peak at some Web API’s today in hopes of finding one I liked to make a mash-up using our AJAX Grid product. I think that I might try out the eBay one since they have some good sample code and it should be real easy to integrate - plus the data is pretty well suited to a grid format of course. Aside from the actual API, the thing that had me most interested was their user agreement - which I surprisingly actually read!

The interesting part was where they say that:

You may not co-mingle, modify or display the eBay Content with the content of third parties … the eBay Content is segregated from non-eBay content, and the eBay Content must be presented in such a way that the eBay Content is visually separate (as with lines or color changes) from non-eBay Content (�eBay Area�); and no third party listings, information or other content of any kind may be combined with eBay Content or displayed anywhere within the eBay Area;

In this day and age of share and share alike in the new Web 2.0, that sort of license seems pretty draconian. However, I think that this behaviour is a great example of the difference between the old (circa 1998) and new webs (today); during the dark ages of the old web there existed what some might consider to be “real” businesses that have now grown to be the data providers - of course data or information is the fuel on which the new web relies. The fresh young face of the new web of hippie-free-lovin mash-up is built largely on the hard work of those companies that survived the first Internet bubble and have accumulated a large amount of _very_ valuable data. As Bill predicted back in the day - content is king. Of course Bill is still doing ok I am sure. Going forward it will be interesting to see if and how the various Web 1.0 (for lack of a better term) powerhouses start charging for access to all their tightly guarded data.

Technorati Tags: ebay webapi web2.0 business

Posted in Web2.0, Business | 2 Comments »

May 24th, 2006

Well, Captain AJAX and I finally got around to making our first podcast! It is a bit long and the audio sucks but we will be sure to get that fixed for next time . Anyhow, Dre and I just talked about everything that happened in the past coupld weeks including Dre’s findings down at JavaOne, The AJAX Experience, DCamp and NetBeans Day.

We also talked about the launch of Nitobi Grid V3…and what's to come down the road - WARNING - could be considered shameless self promotion but we also talk about some AJAX technology stuff

Here is the podcast care of Audioblo. If anyone has any tips about posting and or making the old podcasts then let us know!

Technorati Tags: ajax podcast javaone ajaxexperience

Posted in Web2.0, AJAX, JavaScript, XML, Architecture, Business, Flex, Declarative Programming, Components | No Comments »

May 23rd, 2006

Looks like I will be talking at Web Visions this year on July 20th in the beatiful city of Portland, Oregon. I will be talking about all sorts of AJAX magic from Google Maps and building declarative AJAX applications to important AJAX design patterns and usability.

Should be a good time and I will probably learn a heck of a lot about web design and usability

Looking forward to meeting lots of the other great speakers as well. Some of whom are the likes of Nate Koechley and Bill Scott from Yahoo! and James Reffell from eBay.

Luckily I am not really as bas-ass as my headshot makes it seem so if you will be there then please drop me a line and we can meet up for a beer or another tasty beverage!

Technorati Tags: webvisions ajax web2.0 usability

Posted in Web2.0, AJAX | No Comments »

May 19th, 2006

We have just put together a little demo that uses the Adobe FABridge library for their new Flex technology and married it with our AJAX Grid control.

Check out the cool screencast here on our Nitobi Labs site. Essentially what it lets you do is plot data from our Grid control using the Flex / Flash.

It should be even more cool once we put in our newly released, cross-browser, AJAX Grid component (which I will post a screencast about very soon)!

Technorati Tags: ajax grid web2.0 eba flex flash

Posted in Web2.0, AJAX, Flash, Flex, Declarative Programming, Components | 1 Comment »

May 5th, 2006

The always interesting Ross Dargahi from the Zimbra team recently released a draft specification for something they call AJAX linking and embedding (ALE), which is loosely based on the Windows object linking and embedding. They say that there are two key enabling browser capabilities for ALE. The first capability is “design mode”, which many of you web heads know can be used to specify that certain DOM nodes are actually editable in the browser; this of course is what gives us wonderful Web 2.0 goodness such as Writely. Second, they suggest the use of IFRAMEs as a component sandbox.

At first glance these seem quite pragmatic and give us some powerful tools for creating composite AJAX applications such as mash-ups or (in the interests of Zimbra) documents. That being said I also have some constructive criticism to offer. The first thing that comes to mind is why the need for using design mode to edit content? There are many rich AJAX components out there that do not require design mode to enable editing and in fact using it would likely be a hinderance. I could certainly see the usefullness of having a designMode property on an AJAX component just to notify a component when it should be in an editable state. There are of course a few cases where design mode is quite necessary (like the afformentioned Writely rich text editor), however, that is pretty much the only significant case that design mode is of use. For structures such as trees or spreadsheets, design mode is just not useful. Don’t get me wrong here, I am not suggesting that there is no need for rich online content creation, we just don’t necessarily need to use design mode to achieve it.

As for IFRAMEs, personally I don’t want my rich AJAX components to be confined to one square of screen real estate. The DOM API of a web page is quite a unique and powerful abstraction relative to more traditional user interface paradigms such as Windows Forms, to limit DOM usage to small squares of rich user-interface would be rather draconian. Having said that, when you start building web applications that look and feel much more like desktop applications then it may not be all bad. But then again, the AJAX community is in some ways forcing the desktop to be more like the web, not the other way around

In general an OLE like idea is easily achieved on the web since the entire web page DOM is essentially a rich editor sandbox and linking is easily achieved by including resouces (JavaScript, CSS, images etc) over HTTP. So without using IFRAMES or design mode I think it is safe to say that AJAX is OLE ready. Having not come from a Windows OLE type background I have started to look into the concepts a bit more on MSDN to see what we can take away.

I think that the most important point that Ross form Zimbra makes is that we do need to define some object interface that allows one to instantiate and (de)serialize an AJAX component in a standard way. One big thing missing though is a standard way of getting data into and out of an AJAX component; I think that is the really important piece of functionality that OLE brings to the table. That could mean either copying data from one AJAX component to another or from an AJAX component to a desktop application. I want to be able to select a sweet Google financial graph, press ctrl+c (or maybe apple+c) and then be able to paste that data in my AJAX Spreadsheet. Esentially, as Ray Ozzie pointed out, we need a common Web Clipboard - clipboard is a critical part of OLE or ALE. We have been using pretty much this same technique with our products to copy data from Microsoft Excel to an Nitobi Grid AJAX component and vice-versa.

There are also other kinds of data sharing (like drag-and-drop) and interfacing that need to be standardized to make some really kick-ass mash-ups I think. Microsoft Sharepoint, despite its faults, has some cool and fairly easy run-time connecting of components. Too bad it’s Sharepoint though .

Another interesting dimension of ALE is declarative AJAX. Serialization and deserialization of a component with its data and metadata is very important. We take the approach of defining AJAX components declaratively in a web page which is essentially using a serialized object to build the applicaiton from. This will be key and is the way things are going with XForms (W3C), XUL, XAML (Microsoft) and MXML (Adobe Flex). All this has me thinking more about microformats too … hmmmm.

I will say a bit more about what we can learn from OLE, declarative AJAX and clipboard soon!

Posted in Web2.0, AJAX, Architecture, Declarative Programming, Components | No Comments »

April 21st, 2006

There has been quite the discussion in the past few days about a post from Billy Newport where he claimed that

AJAX enabled applications generate a higher load on an application server than a non AJAX applications

James Governor is not convinced, and Nate Schutta has his doubts, while Tim Bray takes the every pragmatic stance of “it depends”.

Wise Uncle Ben said it best when he warned young Peter that with great power comes great responsibility. In general, I think that AJAX lets developers better take advantage of client side processing of data and therefore on a one-on-one showdown of some piece of functionality, which can be implemented with either AJAX or using the old skool Web, then AJAX will win. For an example of this check out the story on AJAXian about MacRumours and their AJAX success.

However, once you decide to start using AJAX to record the mouse position on the client every millisecond then you are just asking for a world of hurt!

I think that AJAX does generally reduce server load if you are just streaming data up to the client for processing and keeping things simple.

Posted in Web2.0, AJAX, Architecture | 2 Comments »

April 20th, 2006

Ok I have been away for a few weeks so blogging about cool AJAX stuff has been kept to a minimum; however, things are now back to normal for the near future

In fact, the release of the Nitobi AJAX Grid V3 is imminent. Stay tuned, if you are wearing socks be warned that they will likely be knocked off!

Posted in Web, Web2.0, AJAX, Business | 2 Comments »

March 30th, 2006

We got it done only 2 days late and minutes before I had to hop on a plane to go over to London one last time (if anyone wants to meet up and chat AJAX / Web2 then drop me a line).

As for our new AJAX Grid … if you are a customer or not I would love to hear people’s feedback on some of the ideas that I mention here. The Nitobi Grid V3.0 Alpha (video here) is meant to provide our current customers with a better idea of where we are going with our new and improved AJAX product line. If you have somehow heard about the Alpha don’t think that you couldn’t live another day without seeing it then email us and we will see what we can do.

There are three primary areas where we are extending the Nitobi Grid functionality. First and foremost we are providing support for Mozilla based browsers - the Alpha version of Grid V3.0 has been tested (I use that term as loosely as possible for an Alpha) on Firefox 1.5 and Internet Explorer 6.0 (Windows only at the moment). We are planning on officially supporting more versions of Firefox and Mozilla with the final release and will be looking for customer feedback to determine if we want to support other browsers (in the near future) such as Safari and Opera. From our point of view, the reason for not supporting most other browsers is because a) we use both XML and XSLT extensively in our products and b) our customers and the market are not demanding other browsers to be supported.

Secondly, the Alpha version will showcase our new Live Scrolling paging mode - Live Scrolling allows for users to use the scroll bar as though the data is there but the data is actually retrieved and rendered (using AJAX of course) only when the user stops scrolling. In the final version we will support a few different types of paging such as Traditional, and Open Ended (Live Scrolling or Traditional on arbitrary number of records).

Finally, the Alpha also includes a very green version of a .NET 1.1 / 2.0 version of our component. There is nothing too fancy and no designer support at the moment but we should have a nice .NET backend for the final release.

Our minimum requirements for the final release of our AJAX Grid V3.0 is to have all the functionality of V2.8 as well as support for Mozilla/Netscape/Firefox, Live Scrolling and a .NET server backend. There might even be an Alpha version of the JSF backend by that time too!

Other notable features that will be coming in the Beta and final release of Grid V3 include:

Backwords compatibility
Nitobi Grid V3 Alpha is a first attempt at building V3 backwards compatible with V2.x. Is this important to you for the future? If so be sure to let us know and we will work even harder at it - otherwise we will work on other cool features instead.

Copy and Paste
One of the other cool features that we know a lot of people use (and hate to use) is copy and paste. We have not included it now but our new copy and paste functionality is super fast so no more waiting for your data to paste!

Localization
The new Grid will support multibyte character sets for foreign languages although this has not been tested in the Alpha.

Debugging
Like a lot of the new features, we are not quite ready to release the Debugging interface for Grid so when evaluating the Alpha we suggest using MS Fiddler (IE+FF) or FireBug (FF).

Architecture
That being said, there is going to be a lot of advancement that you, the customer, will not necessarily see on the front end. The architecture for Grid V3.0 is going to be the basis for the rest of our product line as we move forward this year.

Component Oriented
One of the driving forces behind our new architecture is to be able to build truly component oriented applications in the web browser and to enable developers to easily extend the functionality through either JavaScript? prototyping or through XSLT. More on this soon!

Declarative Programming
Likely the most interesting part is our move over to a more rich Declarative Model for our components. Our declarative markup is one area where we are very excited to get some customer feedback as it is surely going to not only make our components better but will also be driving internet development over the next few years with technologies such as XAML, XUL / XBL, XForms and Flex really starting to catch on.

DataSource
Another interesting feature that is behind the scenes of our AJAX Grid V3 are a new Nitobi DataSource component which encapsulates all the XML data manipulation such as saving data to the server and merging updates from the server. We want to release this shortly on its own as a simple client side data management solution (licensing TBA). Furthermore, the data management layer will have other important AJAX functionality such as client side data caching as well as predictive data fetching.

Grid V3 Alpha Specifics

Known Issues

• Internet Explorer memory leak (don’t worry this will definitely be resolved )
• Some XSLT files are not cached by Internet Explorer.
  - DocType DTD. What happens in Strict Mode?
• Keyboard navigation can get confused with frozen rows and columns
• Various problems with live scrolling (column resizing, insert / delete record etc)
• Lots more

Other New Feature Ideas

• Record Key generation - how should keys for records be generated?
• Declarative markup - what is easiest for people to read?

New Feature Requests???

Posted in Web2.0, AJAX, Business | 5 Comments »

March 8th, 2006

Today a few of us at Nitobi had a sneak peak at some really cool Flex technology from the team over at Adobe.

Essentially we saw how one can go beyond the ExternalInterface feature in Flash 8, which only supports function calls across the JavaScript / ActionScript boundary with primitive objects, to a situation where one can access Flex objects directly from JavaScript and vice versa. This is being called the Flex-AJAX Bridge or FABridge. All the info (with Alpha download) can be found here on Adobe Labs.

Today this means that AJAX developers can better leverage native Flash capabilities such as local storage (hopefully it is faster than ExternalInterface), cross-domain data access, and sockets. It should get really interesting when the AJAX Client for Flex Data Services become available (later this year) which should provide data persistence, pub/sub, push, etc.

As a component vendor, I like the idea of marrying the benefits of both AJAX and Flex - it particularly makes sense for doing anything with charting etc. With the SVG/VML/Canvas battle for vectors graphics dominance pretty much going nowhere (and they can’t even do video or audio), Flash is the best option for rich media that works on a large majority of today’s web browsers. It was a good move on Adobe’s part to provide some incremental benefit for AJAX developers rather than trying to push a full Flex framework where the open standards of the AJAX technology stack rule. Something like XAML, which is Microsoft’s next generation declarative user-interface language, will have a tough time for that exact reason.

Flex seems to be shaping up into something that should, in the near term at the very least, be a great addition to the AJAX developers toolbox. I can’t wait to get into the guts of it - just as soon as Grid V3 is done

Posted in Web2.0, AJAX, Flash, Flex | No Comments »