sorted by: recent | see : popular

Content Tagged with Announcements + dojo

I am really excited to post this piece of news, as I genuinely like everyone involved. At the last Ajax Experience, Alex Russell and Joe Walker gave a joint keynote. At one point it was going to be slightly different, but this news hadn't been totally completed so it was held off (having to start a UK company, blah blah).

The news is that DWR has joined the Dojo Foundation. This is all thanks to SitePen, which Joe Walker has joined (technically, he has joined the UK Ltd etc).

I am excited to see what will come out of a closer collaboration. Ben recently had to implement a dashboard that needed to tie in to backend Java code, and DWR was a breeze and handled everything for him, including batching, which meant that only a few larger transactions were occurring instead of millions of little calls.

Anyway, back to the news:

“SitePen has experienced significant growth this year and we’re well
aware of the amazing talent and opportunity that will open up by
expanding in the UK, and all of Europe for that matter,” said SitePen
CEO, Dylan Schiemann. “Having a developer as talented as Joe Walker
join SitePen and head up our UK operations is an amazing win for SitePen
and its clients, who will now have access to even more valuable
expertise with DWR and related technologies.”

DWR is an important open source library for Ajax and Java developers
because it simplifies development of applications based on Ajax, Reverse
Ajax, and Comet techniques. DWR will become part of the Dojo
Foundation, home of the Dojo Toolkit, Cometd and OpenRecord projects.
All Dojo Foundation projects exist separately, preserving flexibility
and choice for the varying development communities.

“SitePen is an extremely forward-thinking company that understands the
tremendous value of open source and I’m excited to be a part of it,”
said Joe Walker. “Donating DWR to the Dojo Foundation will allow for
increased adoption and a stable environment in a great organization.”

“Development teams, both small and large, have quickly discovered the
benefits of using DWR in conjunction with leading Ajax libraries like
Dojo, TIBCO General Interface, Scriptaculous, and others. "DWR joining
the Dojo Foundation is a great win for the DWR community," said Kevin
Hakman, director, TIBCO Software, Inc. who has been a corporate sponsor
of DWR's development for more than a year. "The close alignment of these
projects, and the anticipated integration points between them, will
serve to further simplify creating Ajax applications for Java developers."

A huge congrats to Joe, Dylan, Alex, and the rest of the teams.

Congrats to the entire Dojo team on shipping Dojo 0.9. In short, you can now expect great things from this revamp, including a tight, fast core, a unified good looking set of widgets, and an extensible space for all things Dojo.

Now that this new base is out there, the team can continue to build on it, and take it to the next level. Bye bye 0.4, hello 0.9.

Alex says it best:

After a complete re-think about the purpose and value of Dojo, and after
months of grueling ground-up work on the part of the entire Dojo team,
I'm happy, proud, and excited to announce that Dojo 0.9.0 is available and AOL is already hosting 0.9 in their CDN.

For those porting Dojo applications from previous version of the
toolkit, you can refer to the Porting Guide for help on where APIs landed in the shuffle

In may cases, you'll need less code overall to get the same thing done
(or done better), and Bill Keese (Dijit Project Lead) has put together
a great overview of what's new and awesome.

The quick rundown of 0.9 features:

Dijit

• unified look and feel for all widgets
• ambitious a11y and i18n features in every Dijit widget
• a mature CSS-driven theme system with multiple, high-quality themes
• huge improvements in system performance
• data-bound widgets
• Declarations for lightweight widget writing
• a new page parser that allows instances of any class, not just widgets
• no magic

Core

• reduced API surface area (easier to remember and use)
• dojo.query() always available, returns real arrays
• from-scratch high-performance DnD system
• Base (dojo.js) is 25K on the wire (gzipped)
• dojo.data APIs finalized
• new build system
• new test harness for both CLI and browser use
• dojo.behavior now marked stable and based on dojo.query
• excellent animation APIs with Color animations in Base (always available)
• all the features you've come to count on from Dojo (RPC, JSON-P, JSON, i18n, formatting utilities, etc.)

DojoX

• high quality implementations of previously experimental features: gfx (portable 2D drawing), data wires, offline, storage, cometd, etc.
• dojox.gfx now includes Sliverlight support
• many more features and improvements than there's room for here.

TurboAjax Group is proud to announce the release of the TurboGrid 3 beta version. This long awaited release supports virtual scrolling, column sizing, compound rows, variable row height, dynamic sizing of columns and grid, fixed columns, tons of events, and much more.

TurboGrid is currently available for download for evaluation purposes. Additional licensing options will be available shortly. Please go to TurboAjax for more information of check out a demo and read the docs.

The Grid is built on top of Dojo.

I’m happy to announce the first and hopefully last release candidate (zip) for Dojo 0.4.2. As usual, you can grab your favorite builds from download.dojotoolkit.org. 0.4.2 is a minor patch release to address the most severe issues and regressions in 0.4.1. Unlike 0.4.1, there are few if any new features. We encourage adventurous users of 0.4.1 to try the release candidate and give us feedback. The final 0.4.2 release is tentatively scheduled for two weeks from now.

While 0.4.2 doesn’t include new features, the build system has changed significantly thanks to the hard work of James Burke from AOL. It now supports cross-domain builds even better and a new sub-domain, build.dojotoolkit.org, has been setup to support a brand-new web-based build tool. The 0.4.2rc1 build page is up and it includes details on how to use the simple x-domain inclusion script that we’re maintaining for all new releases. Significant work has gone into 0.4.2 to ensure that x-domain builds work correctly and the new web-based build tool will let you easily generate a new dojo.js file to optimize your deployments without ever needing to download the “source” of Dojo or learn how to use Ant. I’m tremendously excited about this.

Beyond 0.4.x: 0.9 and 1.0

Work continues on ensuring that 0.4.2 is the highest quality Dojo release to date, but major changes have also been quietly taking place. At last month’s 3D2 significant decisions were made about how to evolve the toolkit. First, Dojo 1.0 will ship this year. Secondly, we will be splitting the project up into 3 separate but coordinated efforts: dojo core, dijit, and dojox. Lastly, it was decided that a major backwards incompatible jump will be made for the next major release of Dojo. To date, we have always attempted to provide at least one full point revision’s warning regarding APIs that were changing or being removed. This policy has allowed attentive users to easily stay abreast of porting their applications between Dojo versions but it has also contributed significant cruft to the core of the toolkit. This cruft will be removed wholesale in the next major revision, Dojo 0.9. No in-code deprecation warnings will be provided. Instead, a full and complete porting guide for 0.4.x users will be created. The extent of the planned changes make back-compat shims unrealistic.

In the coming weeks we will be outlining the details of the project split, but the major outlines of how to proceed have been decided and are already under way. The first part of the plan involves restructuring the Dojo subversion repository to represent the three major projects. The roles and responsibilities of these projects and their leads are also being clarified:

1. dojo core will consist of a tightly constrained set of lower-level APIs that make JavaScript better as a language and make DOM manipulation easier. All code in the core (and its widget-focused sister project, dijit) will be required to meet stringent quality, testing, and documentation standards. Most of the code currently in Dojo’s utility namespaces is being pored over and most will be either discarded outright or moved to dojox. The resulting core will be very lean, stable, and fast. I will continue to be the project lead for the core effort.
2. dijit is the new home for the “official” widget set. Not all of the current widgets will make the cut for Dijit and only those that are accessible, internationalized, themed, tuned for performance, and agreed to be generally useful will be part of Dijit. The widget system is being significantly streamlined to support this effort. APIs for base widgets are being rationalized, the inheritance hierarchy drastically simplified, and the page parsing infrastructure scrapped in favor of a much higher performance approach demoed at 3D2. Bill Keese, the uber-capable and dedicated module owner for the widget system, will become project lead for Dijit.
3. dojox will carry on Dojo’s strong tradition of invention. Many of the most important Dojo modules push the edges of what’s possible and have helped to bring the theoretical into the plausible over the last 2 years they will be allowed to thrive in dojox without the restrictions placed on core and Dijit code. Dojox will impose fewer restrictions and regulations on projects developed there. Far from being a second-class code ghetto, dojox will be home to important modules like dojo.storage, dojo.gfx, and dojo.charting.

No matter what project a module “lives” in, the entire spectrum of modules will continue to be available from an evolved version of the new web-based build tool.

I know this post has run long, and so I’ll finish with a brief word on timing and leave the inevitable slew of questions for discussion on dojo-interest and to follow-up blog posts. In the next several weeks we expect to have a solid first draft of the 0.9 API specification for the Core. Based on that and progress in porting widgets to Dijit and migrating code to dojox, milestone releases will be made available for the adeventurous starting sometime in March. The current plan, subject to some play in the joints, is for an alpha release of 0.9 in late spring, a beta shortly thereafter, and 0.9 final in early to mid summer. From 0.9 to 1.0 we are targeting testing, completeness, and few if any API changes in the Core and Dijit.

Dojo 1.0 will be available in late summer or fall of this year.

At Dojo 3D2 this weekend, I announced that IBM’s Ajax for WebSphere® Platform is now available on the Early Adopter program website. This initial release includes Dojo Toolkit 0.4.1 as well as a comet implementation for WebSphere Platform Messaging (v6.0), and three end-to-end sample applications that illustrate how Dojo can be incorportated into J2EE applications running on existing WebSphere platforms. All of the features (including an offline version of the draft Dojo book) are packaged for use in Eclipse 3.2.1 development environments, as well as a distribution for non-Eclipse developers. See the getting started guide for details of prereq’s needed to run the various features.

The Dojo Community Resouces project has not been forgotten! Lately there have been many comments to the mailing lists regarding my last article requesting input on a Dojo Community Resource website. Well it hasn’t been forgotten. Infact the project that is more or less being the test bed for its community building software is underway and has been well recieved by the other contributors.

Some of the Dojo Contributors (myself included) are working on a project using the same CMS software (Drupal), once we’ve got this going and are more comfortable working with the software, the Community Resource site will be started. Currently I am still looking for a good domain name to register for the Community site, but thats only minor compared to actually setting it up, but if you have any good ideas for names, feel free to pass them on to me

If you have any comments or suggestions, don’t hesitate to leave a comment!

What I am hoping to achieve by writing this article, is to receive community feedback regarding the construction of this community resource. Now that I have said all that, here are the things I hope to see achieved by the creation of this community resource.

1. Community written module/widget hosting that is outside of the scope of the Dojo Contributor License Agreement
2. Support forum for posted modules/widgets
3. Community written FAQ/How-to articles
4. Community driven content (Relating to but not necessarily limited to technoligies where Dojo can be used)
5. Community written JS Library/Toolkit/Framework etc. comparisons
6. Dojo anything! Links to articles, personal blogs, write ups, news articles websites that showcase Dojo, companies that use Dojo…. Literally ANYTHING! (anything legal anyways )

Note: This is not a replacement to the http://dojotoolkit.org website but rather a collaborative site that allows for unofficial modules and widgets to be collectively offered to the Dojo Community. Code contributions to this site would not require Contributor License Agreements, the poster will maintain liability for content provided by him/herself in this case. Just because this site won’t require a CLA, this should not be seen as an easy way out to contributing to the Dojo Community, contribution of good ideas and useful code is still encouraged to be made directly to the Dojo Toolkit project.

As everyone knows, the Dojo community has been expanding at an enormous rate since the release of Dojo 0.3.0, and with it that growth has come the question; “Where can we find Dojo resources on the web, that aren’t direct products of The Dojo Foundation?”. This of course has been addressed in the past, but in a passive manner, nobody has yet taken an active role in solving this problem. Consider this article step #2 in the process of solving this problem. Step #1 was of course my brainstorming and researching possible ways of approaching this.

As of this past weeks IRC meeting in #Dojo-meeting, it has been decided to work towards integrating a Forum system into the current list of Dojo resources and the need for a “Dojo Resources” type community was also addressed. At this time, I believe that the “Dojo Community Resources” site could very well be hosted off the normal domain, in fact I would encourage it to be on its own namespace (to steal a term from Dojo/Javascript). By moving this project to a seperate domain, it will I believe, remove liability from the Dojo Foundation, for submissions that may have been made without prior authors consent. My idea on this is that the submitter would maintain liability for their submissions, if this is at all possible. Of course I am not a lawyer, so this is just my idea how I would like to see things work.

Why I am writing this article? Well, I believe that this is to be a resource for the Dojo Community, that it is only right that you the community, should have some idea of what is being considered for your benefits. As it stands, I have volunteered web space from my personal account, as well as to purchase the domain name (yet to be determined). As for the resources available to make this happen, I have been considering using a PHP framework/CMS to meet the “community” aspect of the site, and preferably one that has a forum project integrated into it. It has been suggested that the scope of this search should be extended beyond just PHP software, so I’ll be entertaining a few suggestions on that as well, however my strengths lie in PHP and JavaScript so I’ll admit that I am biased towards that as a solution.

What projects have I looked at? Well in my years of playing “Web developer” I have experimented with several of the CMSs out there. Among them I have used: Joomla, Mambo, phpCake, MKP, and most recently Seagull. Of all these, there are various forums associated with them or that have been integrated by third parties, however only one of the forums really supports the features that we were looking for to integrate into the current Dojo resources; FUDforums which is integrated into the Seagull Framework. So that is what I am hoping gets adopted by as the forum of choice for Dojo; not only because it supports all the features we want, but it is also supported by the PHP framework that I am wanting to use for the community site.

Basically what I am aiming for is a site where the community contributes most of the content. I am hoping for a small amount of help from at least 1 other Dojo contributor in order to be mediators between the Community and the Dojo contributors. I would also hope for several trust worthy and knowledgeable community members to help maintain the community forums and such as well. These people would be working on site layout etc, forum moderation, and if capable, feature modification/creation to meet the needs of the community site.

If you have any comments or suggestions regarding what would aide in creating the best “Community Resource” website out there, by all means post a comment below with your ideas and recommendations. As I am wholly expecting the Dojo Community to play a major role in how this project starts, evolves, and runs. To make that possible, I’m counting on loads of feedback and cooperation from you, our Community.

The Dojo Toolkit has a new version 0.4.1 release.

We talked to Alex Russell about the release:

What is good about 0.4.1

It's a stability and performance release so we recommend it for everyone who was already using 0.4.0. For those folks, it should be a very straightforward upgrade. The last major release added a lot of new features and in the intervening time we've had a chance to shake those things out a bit more. Notably:

• James Burke's excellent work (thanks to AOL) on safe cross-domain XHR has yielded a solution for IE 7. This is the best way to do serious, safe cross-domain work while we wait for something like Doug Crockford's <module> proposal to be implemented by the browsers.
• resource and localization "flattening" for builds makes the system perform better when using i18n.
• a native dojo.storage provider for the WhatWG storage APIs. Apps that have been using the Flash storage provider don't have to change any of their code to take advantage of it. It Just Works thanks to Brad Neuberg.
• we spent a *lot* of time adding documentation for many of the previously opaque modules. Owen Williams, Carla Mott, and Neil Roberts have been building tools and herding cats to get this done.
• Bill Keese and Liu Cougar closed more bugs than everyone else combined while they polished and and improved the widgets. Everyone using widgets should see the impact of their work in improved reliability.

Why should people upgrade?

If folks were holding out on 0.4.0, I think think they'll be happy with the state of thing in 0.4.1.

What is next on the agenda?

We're keeping the roadmap at:

http://trac.dojotoolkit.org/roadmap

What's not outlined there right now is that we'll be plugging the new data binding layer into the widget system and making changes to the template syntax to support that. This is exciting work and the culmination of a huge amount of background work by some very smart people.

Data binding will allow us to more quickly attach widgets to services and systems, and I'm excited that we're in the home stretch for getting it done.

The last RC build before Dojo 0.4.1 will be released is now available. Lots of niggling bugs have been fixed since RC1 and thanks to James Burke of AOL and Adam Peller of IBM, some new infrastructure for more efficiently handling localized resources is part of this build.

Also thanks to James Burke, the cross-domain Ajax profile is available as part of the standard set of builds. This means that you can test out the 0.4.1 cross-domain packages from the release directory before they’re available on AOL’s CDN.

Today, Greenplum and SitePen announced the contribution of the new Charting engine to the Dojo Toolkit. Originally designed as the foundation for the Greenplum Monitor–a browser-based database monitoring application to be released later this year–the Charting engine is a cross-browser way of creating very complex charts easily, that can be updated on a regular basis. Some of the features include:

• A Chart can have multiple “PlotAreas” (the actual charts)
• A PlotArea can contain multiple Plots (x/y axis + N data series)
• Data series are bound at run-time to a dojo.collections.Store object, with flexible field bindings.
• An Axis can have custom labeling schemes.
• See below for plot types.
• Each plotter can take a function at render, which will be called for every data point in that series–the node representing the point is passed, as well as the entire source object the point represents.
• PlotAreas provide a facility for assigning colors to series (basically it has a built in HSV generator)
• All browsers but WebKit are supported in full.
• Rendering can be granular; right now the test only runs rendering once, but it was designed to all of constant rendering if needed.
• A range of data points can be plotted (instead of the full data set) if so desired.
• Trend methods are available for data analysis (but no specific plotters are built for it yet).

The Charting Engine supports the following types of plots:

• Grouped
  • Bar
  • HorizontalBar
  • Gantt
  • StackedArea
  • StackedCurvedArea
• Individual
  • DataBar
  • Line
  • CurvedLine
  • Area
  • CurvedArea
  • HighLow
  • HighLowClose
  • HighLowOpenClose
  • Scatter
  • Bubble

At some point there will be a full article on how to use the new Charting Engine, but for now, you can take a look at the test page to see it in action.

The Dojo team is eyeing a full release for Tuesday at The Ajax Experience (a lot of the team will be here!).

Today they put out which will probably be the final release candidate, so baring any issues in testing we will be ready.

Dojo 0.4 Features

• GFX Library
• Internationalization infrastructure
• dojo.debug.console: console logger, improved debugging with Firebug
• dojo.html.metrics - scrollbar width measurement, current font size measurements, the ability to get how much of an HTML fragment will fit on a single line in a container, and to populate a container node with as much of an HTML fragment as will fit into it. Also included is a way of measuring the dimensions of a node if one was to populate it with a specific HTML fragment.
• Widget Infrastructure: namespace support, subwidgets, refactoring of dir structure
• Widgets: New widgets have been added and updated including: VML support, FilteringTable widget, Slider, Toaster, DropDownTimePicker, RadioGroup, Clock, ProgressBar, Datepicker, Editor, AccordionContainer, and many more.

Read more in the release notes, and stop by Alex Russells Dojo session at The Ajax Experience for more info. We will put up information from his talk.

While I’m at it…the Chart widget is working in full right now in Internet Explorer: check it out. While there’s some major refactoring going on with it right now, it should remain stable enough for use in the following browsers: Firefox 1.5+, Opera 9+ and Internet Explorer 5.5+/Win. Current chart types include line, bar (series), area (added today, will be there tomorrow), scatter, and bubble. The only known issue is with Opera 9 and the bubble chart (apparently it doesn’t like some attributes).

In the very near future, the data model underlying Chart will be rewritten to use the new SimpleStore class created for the FilteringTable widget, also recently added.

Near future meaning the next few days.

As with the last post, I should ask: are there any requests for specific chart types? Feel free to leave comments!

I’ve just finished some final touches on FilteringTable, SortableTable’s big (I mean BIG) brother…complete with multiple column sorting, much cleaner data access, the ability to filter, sorting in place, data binding to a simple JSON-based data store…

There’s a lot there, so for now I’ll point you to the tests in the nightlies. Current feature list:

• Multiple Column Sorting (number of columns settable, default is 1
• Sorting in place (non-destructive)
• Per-column programmatic filtering
• Add and remove rows on the fly
• Update field values (with typing) on the fly
• No restrictions on sorting on markup

…I’m sure I’m forgetting something.

Behind all of this is a simple DataStore object, which the FilteringTable is bound to; all of your updates are made to the store, and the FilteringTable will update automatically. This data store is based on an array of JSON objects, and each object in this array can be complex–and you can use the results of methods to display data in the FilteringTable!

This widget was designed to replace SortableTable; if you are working off nightly builds, I suggest you try this out, and give it a spin, and see how you like it.

On Thursday, June 29th, I’ll be doing a 1-day workshop in London, Building Web Apps with Ajax. I’ll be spending the day showing how to build an app with Ajax and Dojo.

The host, Carson Workshops, is sponsoring a contest for free admission for the day. As a former resident of Los Angeles, I felt the need to spice things up a bit and give the lucky (work with me here people) winner the full VIP treatment by personally delivering to you your very own black, first edition, Dojo t-shirt.

The catch: you need to send me ( mail -at- dylans -dot- org ) a short description of an idea you have for building an app with Dojo. And of course, you need to find your way to London on June 29.

Update: I’m setting a deadline of the end of Friday to receive entries

Ever wanted to use Dojo in an app without thinking about where to set up the files or which build to pick? Now you can.

AOL has one-upped their already generous sponsorship of the toolkit by donating code to the toolkit that allows the package system to work across domains and hosting a new build of 0.3.1 in AOL’s CDN. This is the culmination of a bunch of great engineering by James Burke of AOL. His mailing list post has all the details on how to use this new package, which you can also download for use on your own projects and internal sites.

Folks watching the checkins mailing list carefully in the past month will have noticed a number of checkins with the word “IBM” in the checkin comments. These commits have included non-trivial additions to the toolkit like real i18n support, and we’re tremendously grateful to IBM for these donations.

Today, IBM went a step further by announcing their support of the Toolkit and the Foundation. IBM’s involvement is helping to mature the toolkit in areas like accessibility and data binding which help preserve the reach of Ajax applications and lower the costs to both users and developers. Through partnerships with companies like IBM, SitePen, JotSpot, Renkoo, and AOL, users can be assured that Dojo’s vibrant and growing community will continue to support them through the entire spectrum of applications, from lightweight UIs for consumer internet apps to data-rich intranet dashboards.

To say that we’re excited to be working with IBM is something of an understatement. With a bit of luck and a lot of hard work, we intend to show you in the coming months why we think this partnership is so important in the only way Open Source projects know how: with great code.