Dojo consists of, as far as I can tell, at least two different major sub-projects, The Javascript Library and The Widget Toolkit, as I'll call them.

There may be one or two other major subprojects, which I will, for now, collectively refer to as The Charting Engine, being a set of graphics and graphing APIs (and a whole bunch of Dojo contributors who have slaved over this code egg Andrew's apartment).

I personally believe the achieved goals of Dojo have been two-fold, with respect to every part of the project:

• Iteratively improve on the way current Javascript implementations do things (including glossing over platform differences and flaws). This appies to APIs, interface patterns (read "widgets"), etc.
• Provide a set of tools to build the dynamic interfaces that have become increasingly popular (as seen on the internet).
  

These are the kind of goals that are easy to accomplish in an open source project, but which don't really provide a bold flag to wave.

The Javascript Library

The Javascript library can be broken into two classes of goals. Although the goals are largely independent in conception, they tend to become unified in practice, because (for example) smoothing over the differences between event implementations and providing a much more powerful event API can be done at the same time.

Generic Cross-Platform APIs

Dojo aims to create a single common API that smooths over the differences between different Javascript implementations. This can be divided in to two (possibly three) main areas of effort:

• Core JS (Storage, IO, string, math, etc.)
• Client-side JS (DOM, Events, etc.)
• Server-side JS (? Possibly, I'm not sure)

Improving On Javascript

Creating APIs that enable things that are impossible, or at least very difficult, in Javascript in any implementation. This breaks down into programming-driven goals, rather than implementation-driven goals:

• Classes and Inheritance
• Events
• IO
• Storage
• Graphics
• Animation
• etc.

NOTE: It is my belief that is should be the goal of Dojo to get all or part of this "Javascript standard library" into the next generation of implementation distributions.

The Widget Toolkit

Note that I don't say UI toolkit. Building good UIs that are really efficient and truly humane requires, in my opinion, ground-up event-driven programming. When we speak of UI toolkits, we are really refering to a collection of pre-built "user interface building blocks", or tools for creating such building blocks. That's the closest I can get to a definition of the word "widget", hence, Dojo as a Widget Toolkit.

Widgets do, or should, broadly fall under two categories: Input (gathering information from the user), and Output (clear and useful presentation of information to the user).

Input Widgets

Improved Core Input Widgets

HTML provides a set of core widgets; it is clear that these widgets are sadly lacking from a programming point of view. Dojo attempts to fill in the gaps by providing better versions:

    * Button
    * Various Dropdown lists
    * Checkbox
    * Dialog
    * Form
    * Various type-driven text boxes
    * Various Rich Text Editing Widgets
    * Autocomplete Widget (if Dojo doesn't have it, it should)

Extended Set of Core Input Widgets

Dojo also provides additional core input widgets:

    * Slider
    * Spinner
    * Date-pickers
    * Color-pickers

Output Widgets

Note that several output widgets contain input widgets, either as part of their information presentation (filter tables, etc.) or as part of the information they present (tree widgets, etc.).

Interactive Information Presentation Widgets

These present information to a user in a way that allows and/or requires users to interact with the widget in order to gain access to more or less information.

    * Various Tree Widgets
    * SlideShow
    * Wizard Widgets
    * Filtering Table
    * Accordian Widgets
    * Panes

Dynamic Information Presentation Widgets

These take a relatively small amount of information (e.g., csv or xml data) and generate nice presentations of it on the client side. These presentations can be dynamic also in the sense that they are animated.

    * Progress Bar
    * Where are the rest? Why is there no high-level Widget style inteface to the charting system? Or is that accomplished basically with Pane + [charting code]?