https://github.com/deftjs/DeftJS/issues/21

1) Looks like Neil already pitched in with a great answer here.  Thanks, Neil!

2) Unfortunately, Sencha Architect does not currently support Deft JS.  I’m not sure Deft JS even existed at the time they began development of that tool.  Feel free to let Sencha know you’d be interested in seeing support for Deft JS and other third-party libraries in future releases of Sencha Architect.  We’d love to see this, too.

3) What kinds of exceptions are you interested in dealing with?  One of the other tentpole features of Deft JS (not discussed in this article) is Deferreds / Promises.  This feature allows developers to write methods that return a placeholder for a future value, and chain multiple asynchronous operations and transform their results into that resultant value using very natural syntax.  Included among those capabilities is the ability to handle and recover from an error that occurs within a chain of asynchronous operations. This portion of Deft JS is still in development, but you’ll be hearing a lot more about it soon.

You might well not need it. We definitely do not advocate Deft JS as the one-size-fits-all solution to all web interactivity - in some cases it might be overkill. It is best suited for large scale single page applications where the UI is significantly dynamic. View Controllers allow a separation between the definition of the view, and the underlying logic for coordinating the state of subcomponents of that view and subsequent delegation of work to business logic components. They are not an invention of Deft JS, and similar implementations can be found in most modern application frameworks. For larger applications with dynamic user interfaces, this separation of responsibilities can be critical for developing a manageable and maintainable code base.

Q: 1.How is this simpler than the ExtJS MVC? That one is already overly complicated and many users don’t use it since it brings more problems than it tries to solve.

A: Ext controllers are weird in that you have one controller but multiple views. This means you should never store a reference to the view, making the whole refs feature useless. The Deft controllers are one controller per view instance, meaning you can store state in the controller if you want. It’s much less work to create a getter for a view sub-object and to handle its events.

I haven’t tried integrating with Ext.ux.RoutedApp, but I can’t think of any reason why it shouldn’t work.  You could potentially omit the controllers configuration and use Deft’s ViewControllers (or use both if you’d also like to use view-less application-level controller).  As with integrating with Ext.app.Application, I would recommend configuring your IoC container in Ext.onReady() rather than in RoutedApplication::launch() because any controllers, stores specified via the ‘stores’ or ‘controllers’ configs will be instantiated in the constructor before your launch method is called.  Otherwise, any dependencies those controllers or stores might have will not be fulfilled because the IoC container will not have been configured yet.

I have a container(my view) that contains a form that contains some items.
It it possible to inject(using the control annotation) some of the items(e.g : the submit button) that reside inside the form?

Thanks,
Shay

How do I do this using Deft? Thanks!

You could potentially loosely couple your view references by configuring the IoC container to resolve alternative concrete view implementations for BIDI vs non-BIDI.  However, you’ll lose a lot of the elegant expressiveness of the alias-based JSON-esque component descriptors used throughout Ext JS (such as with the Container.add() method and `items` configuration).  That approach costs you quite a bit of convenience when it comes time to create the view instances.  Unless you need to create and show different localized versions of views and have them visible at the same time within an application, I’d take another route.

Instead, I’d consider creating alternative localized implementations of each of your views, packaging each set of localized views into locale-specific auxilliary JavaScript files (loaded separately from Ext JS and the rest of your app), but using the same aliases across locales.  Once you determine the user’s desired locale, you would load the file with the appropriate localized view implementations.  If the fields and underlying logic themselves are the same, you could potentially even use the same Deft JS ViewController across various localized view implementations.

Additional capabilities explicitly designed to aid internationalization are on the Deft JS roadmap, but they are not currently scheduled to be part of the 1.0 release.

Would you recommend using this for internationalization?

I also did my own js framework on Ext Core and some extentions from ExtJS.
It is here http://mtjs.org
It is ixtremely fast.

If I have sponsor that could supply my work during 8-16 month I would finish it up and get the world leading framework.
I would like implement UI like these
http://dribbble.com/shots/512508-Notifications
http://www.moreira.ch/
http://vectormill.com/

As a fellow Adobe Flex refugee, I’ve found both frameworks to be exciting alternatives in the HTML space.  I’ve used both Angular JS and Ext JS and my preference for a given project would vary based on the complexity of the UI and associated UI componentry required.  For single page applications with a desktop application style experience, with menus, trees, grids, etc. there is no question Ext JS is a clear winner.  I recently participated in the development of a proof-of-concept application of that type that took 6 weeks (each for two developers) to develop in Angular JS that I was able to rewrite in 3 days with Ext JS and Deft JS.  I love Angular’s MVVM implementation and transparent binding (its a beautiful implementation), however reinventing common UI component and adapting third-party components as directives is only viable when you only need a couple rich UI components that are outside the standard HTML suite of controls.  Ext JS provides a rich suite of components with consistent APIs, implemented in an OOP fashion for easy extensibility. Deft JS brings an Ext JS-style implementation of the few key Angular JS features that Sencha’s frameworks lacked, such as an IoC container for dependency injection, view-scoped controllers and Promises/Deferreds.

A few of the questions here relate to Ext JS rather than Deft JS.

Rich02818:

Deft JS extends Ext JS with an IoC container for dependency injection, an ViewController-based MVC implementation and Promises/Deferreds.  It is open-source and licensed under the very permissive MIT license.  Feel free to contact me directly if you need alternative licensing terms. 

While you can freely use Deft JS within a commercial product under those terms, Ext JS itself is separately licensed.  You can refer to this page: http://www.sencha.com/products/extjs/license/ to learn more about their licensing terms.  Sencha Touch is offered under a different licensing model: http://www.sencha.com/products/touch/license/.

magdy a aboud:

Your questions relate to Ext JS rather than Deft JS.  You might try their support forums: http://www.sencha.com/forum/

Deft JS is only a couple months old and currently in beta.  We’re actively using it ourselves to deliver work for clients, but I’m sure you can empathize with the fact that we have to keep a roof over our heads and those projects have deadlines.  Sadly, community support and evolution of the documentation for the framework itself is not our day job.  As an MIT licensed open-source project, Deft JS is a gift to the Ext JS development community that originates from what spare hours are available in our nights and weekends.

We have a vision for what Deft JS will be and are actively pursuing it.  We are very excited that Deft JS has already attracted as much interest as it has so early on in its life.  In its current form, it already pushes the envelope for the kinds of applications you can build and deliver with Ext JS and Sencha Touch.  We have more surprises in store.  You ain’t seen nothin’ yet.

But in the meantime… we are working to move the core framework out of beta into version 1.0.  This effort includes addressing key concerns that early users have reported, documenting and implementing tests for Deferreds and Promises (a feature of Deft JS not discussed here), improving documentation overall, developing meaningful examples, migrating to Sencha-style documentation (using JSDuck), and creating a revised project website (to replace the dressed-up README.md we have there currently).

No small order.  But we’re up to the task.  You just might have to wait a little while longer.

We are grateful that Sencha provided us this opportunity to announce the project to their community of developers via this blog.  The response has been extraordinary and overwhelmingly positive, and the feedback has been immensely useful.  We are excited that developers across the globe are already using this framework to build web and mobile applications.

We are even more excited that developers like Brian Kotek, Jacob Henry, Rowan Crawford, Josh Nesbit, Isaac Johnston and others have filed bug reports, offered suggestions and even contributed code to improve this project.  Deft JS is an open-source effort, and as such thrives by community contribution.  We’re excited that an active, contributing community is already emerging around this project.

Since this guest blog was posted here we have released multiple updates to the framework addressing issues filed on GitHub or discussed on our Google Groups forum.

You might be interested in the Deft JS Google Group:

  http://groups.google.com/group/deftjs

We manage our project on GitHub:

  https://github.com/deftjs

There you can find our latest source code and development branches, as well as file bug reports and track their progress.  We’ve closed several issues and have multiple enhancements scheduled for upcoming releases.

https://github.com/deftjs/DeftJS/issues

Brian Kotek was kind enough to create and share a small example application on his blog:

  http://www.briankotek.com/blog/index.cfm/2012/5/8/Exploring-ExtJS-with-DeftJS

While I wish we were able to provide you with a large-scale example application today, we are currently unable to do so.  If I gave you the code for the intranet applications I’m developing currently for my employer’s clients, I suspect I’d end up with a lot more time to develop Deft JS but a much tougher time paying my bills.  That said, we are aware that meaningful examples will be critical to ensure Deft JS’s long-term success and they are slated to be available as soon as we possibly can build them.

Best regards,

John

Other than my concerns about that, I think it looks very promising and will have to give it a go!

Troy
http://www.osisecurity.com.au

Just clone the stuff right into the sencha example folder.

http://www.briankotek.com/blog/index.cfm/2012/5/8/Exploring-ExtJS-with-DeftJS

Includes a downloadable application, will give it a try.

Otherwise, try to quickly get it to work within my existing application , did not succeed, would help alot if you had a simple working example included in the code, a window with Hello World would help.

Best Regards

Thanks in advance.

Thnx.