[Dojo-interest] Is there any update on Dojo 2.0?

Dylan Schiemann dylan at dojotoolkit.org
Mon Nov 3 15:12:47 EST 2014


Hi Ron,

The challenge with a roadmap for an open source project is that I can
only control ideas and what I work on, and not on what the community
plans to work on.

So, I can try to articulate the current vision as I see it.

* Dojo 2 will be a collection of packages that work well together, but
each of these packages will be released independently. This means we can
release things as they are ready (and have been doing so as you've
noted), get them working on top of Dojo 1, and then pull out the Dojo 1
support for Dojo 2.
* We will continue to release things as they are ready, and when there's
enough that's done, we'll start talking about Dojo 2 release dates
(we're not close enough to that yet, though that could change relatively
soon).

# Language: TypeScript and JavaScript
* We expect to have packages written in each (some will be authored in
TS, some in JS with TS interface definitions provided), so far we are
pretty impressed with TS

# Documentation
* DojoDoc is a superior format, unfortunately, all common tools use JSDoc
* Intern/Leadfoot/DigDug use JSDoc
	* Tool stack for generating docs is not stellar, we can improve that as
needed

As far as what I imagine those packages to be, it's something like this:

# Intern
* Used for testing Dojo 2 (and many other JS projects and apps)

# Dojo Core
* Early Dojo 2 core alpha is available at https://github.com/csnover/core/
* Module loader
	* AMD
	* Node/CJS
	* ES6 (planned)
	* domReady
* kernel
* Language utilities
	* lang (hitch, deepMixin, etc.)
	* string
	* number (planned)
	* regex (planned)
* Observable
	* Object.observe()
	* arrays
	* properties
	* mutation observer
* Events
	* Small refinements on dojo/on
	* Better solutions for debounce/throttle/delegation
	* Evented (emit)
	* aspect
	* topics
	* keys (planned)
	* mouse/touch/pointer events (planned)
* Feature detection
	* Refinements to dojo/has (planned)
* Async
	* Promises A+ (need to fix native promises)
	* all
	* when (planned)
* HTTP Requests (Ajax)
	* Small refinements on dojo/request
	* io-query
	* text (planned)
* Dates
* Local
	* cookie
	* storage (planned)
* i18n/g14n/l10n/etc. (planned)
	* translation
	* messageFormat
	* currency
	* dates

# DOM
* DOM (planned, may leverage jQuery for some or all of this)
	* Convenience methods
	* query
	* NodeList
	* forms
	* window/DOM

# Object stores: dstore
* https://github.com/sitepen/dstore
* 1.0 to be released relatively soon
* Collections (store + query/filter)
* More stores
* Better approach to Observable, layering store features
* Data modeling/validation sub-package

# Class declaration
* Replacement for `dojo/_base/declare` (planned, could be dcl, could be
ComposeJS, could be something else)

# DnD
* Separate package (planned, assuming there will be interest)

# Animations
* May just use CSS3, may pick an existing package, or may implement a
separate package (TBD, assuming there is interest)

# History/routing
* This will be reworked, as what we have today is more basic than we
would like

# Colors
* Early work by IBM on dcolor? (I'm not sure if this makes sense as a
separate package or not)

# A11y
* Collection of helper utilities for widgets (planned)

# Parser
* Planned (may not be a separate package, may live in core or DOM, not
sure yet)

# Vector graphics and charting
* Planned (one or two packages, perhaps dgauges joins this and we create
a bigger visualizations package)

# Widgets
* IBM has early work on delite/deliteful (web components based)
* Perhaps we include support for Dijit with Dojo 2 to provide a
migration path (TBD)

# Grids
* dgrid 0.4 being released this month
* Adds support for dstore
* Not sure of the status of GridX

# Build optimizations
* Needs a rethink/rebuild, should try to rely on Grunt or Gulp or
similar (planned)

# Package management
* TBD (we would prefer to use something on the market rather than
reinvent the wheel, but aren't 100% satisfied with today's options)

# Theming
* Preprocessor (likely Stylus, though we need to evaluate some of the
newer options that have been released)

# Rich Text Editor
* Separate project (planned)

# Migration utilities
* Similar to dojo-amd-converter, but more complete (planned)

There are a few other packages I'm not 100% ready to talk about yet, for
example what's the right application architecture, etc.

As you can see, quite a few things listed above have some significant
progress made on them, so we're far along in some areas, and have barely
started in other areas.

In terms of why you might stick with Dojo, I think it's very easy to
become enamored with the toolkit du jour. Dojo's been focused on making
it more efficient to build robust applications for 10 years, and we'll
continue with that mission.

That said, Dojo 1 was started at a time when we had to be the entire
ecosystem. Today, we can step back, and provide the solutions that we
think are the best, and let others provide things where we don't have a
strong interest. So for example, rather than a big DojoX package, if
there's interest in adding a major extension, it will be done as a
separate project.

I think Dojo's main benefits going forward are as follows:

* Solutions that work together (e.g. the same approach taken with
something like Intern)
* A toolkit with consistent patterns and approaches that add a lot of
power and flexibility when used together
* A focus on performance and flexibility

There's more I could say, but hopefully this gives you at least my
current perspective (and I'm sure there are others that have different
thoughts here, or things I've missed or not articulated clearly).

Regards,
-Dylan

on 11/3/14, 12:27 (GMT-07:00) Ron M said the following:
> I work for company producing enterprise software that has used Dojo from the
> early days, and we are starting to make plans for updating our UI, making it
> more mobile friendly, themeable, possibly use typescript for better IDE
> support, etc. I was hoping that our plans would coincide nicely with Dojo
> 2.0 because from what I have read much or all of this will be easier/better
> with Dojo 2.0. 
> 
> But all I've read comes in bits and pieces. I've seen some updates on
> intern, dstore and dgrid, browsed some of the documentation on deliteful,
> and some comments about possibly using Typescript. The last update I've seen
> though on a date just says that work on it continues. 
> 
> So my main questions are:
> 1) What is an honest assessment of when will it be available? I did see a
> roadmap about a year old that indicates a Q1 2015 release, but I have no
> idea if that is still the plan.
> 
> 2) What is in it, or what are the main differences with 1.x? dstore,
> deliteful, typescript, other? The roadmap I saw mentioned multiple things,
> but many were still TBD.
> 
> 3) Any information on what will be the effort to migrate from 1.10 to 2.0?
> 
> 4) Why stick with Dojo over other frameworks? We have new employees telling
> me all the great things about other frameworks they have used, and asking
> why we don't make the switch to something else. I assume knowing about Dojo
> 2.0 will only help with my response.
> 
> I am asking these questions now because we really need to start making
> decisions on the future of our UI, and I'd like to do that with knowledge of
> what Dojo 2.0 will be and when. 
> 
> Thanks.
> 
> 
> 
> --
> View this message in context: http://dojo-toolkit.33424.n3.nabble.com/Is-there-any-update-on-Dojo-2-0-tp4004162.html
> Sent from the Dojo Toolkit mailing list archive at Nabble.com.

-- 
Dylan Schiemann
SitePen, Inc.
Dojo workshops in the US, Canada, and Europe:
http://www.sitepen.com/workshops/
SitePen Insider: http://sitepen.com/insider/
http://www.sitepen.com/



More information about the Dojo-interest mailing list