# Open Source Theory

**URL:** <https://forums.bitovi.com/t/open-source-theory/975>\
**Category:** DoneJS\
**Created:** [October 8, 2018, 7:46pm UTC](https://forums.bitovi.com/t/open-source-theory/975 "2018-10-08T19:46:44Z")\
**Posts on this page:** 6\
**Page:** 1

<div class="post-metadata">

**Author:** ![justinbmeyer](https://yyz1.discourse-cdn.com/flex035/user_avatar/forums.bitovi.com/justinbmeyer/32/179_2.png) [@justinbmeyer](https://forums.bitovi.com/u/justinbmeyer)\
**Post date:** [October 8, 2018, 7:46pm UTC](https://forums.bitovi.com/t/open-source-theory/975/1 "2018-10-08T19:46:44Z")

</div>

I made a video on the goals of the CanJS, StealJS, DoneJS open source efforts and how those efforts are managed. [https://www.bitovi.com/blog/open-source-theory](https://www.bitovi.com/blog/open-source-theory)

Video: [https://youtu.be/\_8Sz74FsQ7M](https://youtu.be/_8Sz74FsQ7M)

Let me know what you think!

---

<div class="post-metadata">

**Author:** ![Lighttree](https://yyz1.discourse-cdn.com/flex035/user_avatar/forums.bitovi.com/lighttree/32/298_2.png) [@Lighttree](https://forums.bitovi.com/u/Lighttree)\
**Post date:** [October 10, 2018, 4:09pm UTC](https://forums.bitovi.com/t/open-source-theory/975/2 "2018-10-10T16:09:38Z")

</div>

Hi Justin,

Thanks for the video, it is quite inspiring.

I work with CanJS for last 3 years, starting from version 2.2.9.  
All aspects of the framework were improved a lot during this time, its really awesome. Especially I like documentation changes that done (and in-progress) during last year, since this helps with issues that I mention below. There are issues that I think valid to rise, and this thread might be good place. Of course most of them depends on community and investments, so probably they are not new, it just impossible to fix right now. Some of these issues already have proposals to fix.

Before I would like to clarify what pre-conditions I have:  
Currently we have around 14 front-end developers who work with CanJS every day, sometimes Java devs tries to help wight tasks because of different reasons. So my points will be based on their experience and feedbacks from different people. Not all of points might be valid for everyone and some of them are became better this year especially.

I’ll try to split everything to different sections based on different aspects.

**"Why you are using this ?"**

This is the first question that people ask me on interviews, when we tell them that we use CanJS.  
Our story is that year ago when we decided to write “single page application” we had requirement that it should support IE7 (and this was important, because business wanted this), so we had not so many choices: Angular dropped support of IE8, React was too new, Vue didn’t existed 😃 , so we compared with Backbone I think and at that moment CanJS was better choice.  
Nowdays state of frameworks is very different and there are top technologies that most people want to work with. Something like React / Angular / Vue. And its very hard to explain why you should start new project on CanJS, but not on something else.  
This situation becomes even worse when we talk about hiring. People who only start their career want to work with “popular” technologies and market dictates them. More experienced devs who has experience with particular technologies also don’t wan’t to invest their time to something that might be not useful for them.  
So I think it’s very important to explain people WHY CanJS - good framework.

**Newcomers and learning**

Ok, we hired newcomer to the team and he full of energy to learn something new or he is back-end developer who wants to try shiny world of front-end 🙂

He starts to do something, something doesn’t work and… he doesn’t know what to do. In compare to other frameworks, you can find way less info. Worst scenario that I had is when someone said: _“I can learn X framework way faster there are so many courses / articles / tutorials, why I should invest time to something else”_

- _In-Depth Guide_  
So we collected number of resources that we show people to help them start learning. First of them all… [DoneJS In-Depth Guide](https://donejs.com/place-my-order.html). I recommend this guide, because I think this is the best tutorial that currently exist, it covers a lot from development perspective and shows how CanJS application can work, how components work with each other etc. Awesome.  
But first reaction on this is “Why I should read DoneJS ? Isn’t this different framework ?” So you need to explain that DoneJS = CanJS + “Tools” this confuse people alot at the very begging.

- Recipes  
I think that main issue there that there are too many Recipes (Simple / Medium / Advanced)… I know that there is improvement in-progress for this section and as I got amount will be decreased. Still all of them written in different styles so its not clear what is correct approach (I’ll mention this later).  
Additional issue that sometimes they just doesn’t work ☹ And this reasonable… because its hard to support so many recipes and update them every time. So maybe it makes sense to reduce amount of recipes, but make them really great and “production” ready.

- Gitter / YouTube  
Then we show Gitter channel, YouTube channel, this forum. Personally for me Gitter is great place that helps me frequently, but not everyone ready to ask questions there, because this takes time to get answer and sometimes questions might be not answered.

- Essentials  
Newest thing that helps alot is “Essentials” section. Really this helped a lot to understand what to do and how to write better CanJS even for people who worked for some time already. Currently we are using 3rd version, but still I recommend read this section from CanJS@5, because there are still approaches that can be applied in v3.

So currently documentation and information improves alot and its easier to learn CanJS than 1 or 2 years ago, but there are things that can be improved.

**[CanJS.com](http://CanJS.com) and API**

_Homepage_  
_This thing is very opinionated, but I asked several people before writing this_  
When you open [https://angular.io/](https://angular.io/) or [https://reactjs.org/](https://reactjs.org/) these sites looks just visually more appealing and easy to understand. I don’t know about Bitovi internals, it might be that there is reason for this, but some good UX specialist can improve this, by introducing new design, rethink content of the page and its organization. It feels less “professional”, while first impression should be “wow, I want to learn this, its easy !” instead user sees tons of info.

_API_  
This becomes better each release, plus I work with it for a long time, so its hard to find good example to illustrate what I mean, but people who just start work with is usually confused by cases like: “This is Init method. It does initialization” 😃 It just lacks any information about how CanJS works actually. For example we have Component section, but there is no descriptions about component life-cycle or even “init” method that actually exists. And this part of issue with understanding how CanJS works in general.

**Geting more info about CanJS**

Lets split it on 2 options: when you work with CanJS and when you don’t work with CanJS

_When you work:_

For example on YouTube I found 3 channels somehow related to CanJS:  
Bitovi: [https://www.youtube.com/channel/UC\_HPFLeKzJNLOUnLc\_3311Q](https://www.youtube.com/channel/UC_HPFLeKzJNLOUnLc_3311Q) (310 subscribers)  
DoneJS: [https://www.youtube.com/channel/UCEnTQUfJi0L6l7g8IRuaVkg](https://www.youtube.com/channel/UCEnTQUfJi0L6l7g8IRuaVkg) (83 subscribers)  
CanJS: [https://www.youtube.com/channel/UCM\_xC8UOHt2ay5wz-3gotmg](https://www.youtube.com/channel/UCM_xC8UOHt2ay5wz-3gotmg) (189 subscribers)

But all of them might be useful for people who work with CanJS, but based on subscribers I think not all community aware of all these channels. Maybe it makes sense to merge them and not split like CanJS / DoneJS ? Instead its possible to create “Playlists” or Series, similar to what Google Developers have: [https://www.youtube.com/user/GoogleDevelopers/playlists](https://www.youtube.com/user/GoogleDevelopers/playlists)

There was series: “How it works”, but later next videos become random again. I think some kind of grouping may help people.

The same with Gitter channels. There are 6 channels related to Bitovi 🙂 (CanJS, DoneJS, Testee, StealJS, Funcunit, Trainings) maybe it makes sense to merge them as well ? Because in all of them people discuss CanJS related question. (Some channels silent for months)

_When you don’t work:_

Currently I don’t know any resource that advertise or shows benefit of CanJS to external audience.

For example I watched some course from [Bianca Gandolfo  
 ](https://frontendmasters.com/teachers/bianca-gandolfo/) (who works in Bitovi) on [frontendmasters.com](http://frontendmasters.com) why not create some course about CanJS there ? As far as I know they have “training” format with live audience, so might be this is not an option, well [https://egghead.io/](https://egghead.io/) is quite popular as well.

I think having some “course” on 3rd party platform can help CanJS community grow. Or at least people will know that CanJS exists and it makes sense to read about it more.

**"Advanced" CanJS**

After you spent time to learn CanJS you can ask your-self “Am I CanJS specialist ? Am I ready to contribute there ?” And I still can’t find answer on this 🙂 There is no measurable point when you can think that you know CanJS. For example in Angular / React there are lots of mechanisms and internals documented, and when people want to understand level of experience in particular technology they can ask something like: “Can you explain Reconciliation mechanism in React” or “What performance optimization can be done ?”. And because these topics discussed in community or documented such knowledge way easier to get.  
With CanJS there are a lot of magic happening inside that you won’t know unless you read source code. While this is an option, I don’t think this is way that many people do. I remember cases when we developed our first functionality with behaviors and tried to “find” correct sequence of behaviors that will do what we need to do 🙂 At that moment there was no info that position of behavior actually matters, and how they applied from first item of from last.  
So after all this you can’t even say that - yes I know how CanJS.  
“How it works” series is very good, but its quite hard to understand all stuff that happening there 🙂

**Lack of Best Practices**

I think teams with a lot of developers and independent projects should feel this issue. Basically this means that you don’t know what is good way to organize things. This is not about how to use “Modlets” its clear from DoneJS (well you should know about DoneJS if you work with CanJS :D) But even with this, when you check code of Guide or different apps, or discuss how people write something on Gitter its visible that approaches might be very different, and sometimes it wasn’t obvious that this is better way to solve some issue.

Its more about how to write your code, how to organize components, what type of components you may have.  
I think this proposal: [https://github.com/canjs/canjs/issues/3646](https://github.com/canjs/canjs/issues/3646) can answer on this. Part of this questions might be answered in “Logic Guide”. (As I mentioned before this “new” Essentials section is very cool and helped alot)

Still CanJS not so “flexible” framework, it doesn’t make sense to not use some of its core things, like Observables, Connections, Models etc. so it feels like CanJS has concepts that people should follow to get all benefits of CanJS and they should be described somewhere.

For example other frameworks have some terms like “Compound compontents”, “Presentational components” for components, that might help with component organization and make your application more scalable. Some other concepts how to mange state, use Streams, organize data flow.  
Vue has even separate section for some stuff: [https://vuejs.org/v2/style-guide/](https://vuejs.org/v2/style-guide/) React has different parts like “Concepts” or [https://reactjs.org/docs/higher-order-components.html](https://reactjs.org/docs/higher-order-components.html)  
A lot of such stuff also applicable to CanJS, what I personally found for myself is that Angular best practices works quite well for our code base, and our applications looks very similar to how Angular apps structured.

Oh, this is quite long message I wrote 😃 Not all of this directly directed to Open Source Theory, but still might be useful. Anyway thanks for your that you did CanJS really became better each release ! 🙂

Best regards

---

<div class="post-metadata">

**Author:** ![justinbmeyer](https://yyz1.discourse-cdn.com/flex035/user_avatar/forums.bitovi.com/justinbmeyer/32/179_2.png) [@justinbmeyer](https://forums.bitovi.com/u/justinbmeyer)\
**Post date:** [October 10, 2018, 4:50pm UTC](https://forums.bitovi.com/t/open-source-theory/975/3 "2018-10-10T16:50:27Z")

</div>

Thank you so much for writing all this up?

Do you think you could help me create some proposals based around this feedback? I think the following seem the most important:

- Improve the homepage design and give a definitive reason to use CanJS
- Create a “CanJS” version of the in-depth guide and emphasize that.
- Consolidate youtube and gitter channels
- Create a best practices / architecture guide

I’m a bit confused what to propose from the “Advanced CanJS” section. Would continue to add “how it works” sections to our docs help?

Here are some examples:

- [can-query-logic | Data Modeling | API Docs | CanJS](https://canjs.com/doc/can-query-logic.html#Howitworks)
- [can-observe | Observables | API Docs | CanJS](https://canjs.com/doc/can-observe.html#Howitworks)

Regarding:

> There is no measurable point when you can think that you know CanJS

I think providing someone this might be rather hard as CanJS has become so abstract over the years. To understand how `can-define`’s observability works, you need to know:

- How to satisfy `canReflect.getKeyValue()` with the `can.onKeyValue` symbol
- Working with `can-queues` to dispatch elements.
- Working with `can-observation-recorder` to work with computed properties.

Those “how it works” videos were my attempt at answering this question. But even once someone understands how the observables work, then to be really an expert, they will have to know `stache`. The core things about stache:

- can-view-target - the “compile target” of stache
- can-view-parser - an HTML parser
- can-view-nodelist - organizes the stache hierarchy
- can-view-live - Able to keep part of the dom up to date with an observable
- can-view-scope - the scope lookup construct of can-stache
- can-stache - Includes a parser for expressions. Then uses both `can-view-parser` and its own expression parser to generate functions that result in a renderer.

I guess I see people can become experts, but I think it’s easier to become experts first at one part (observables) and/or another part (stache/view)

I’m not sure how to go about solving this problem …

The only thing I can think of is to continue making “how it works” sections on these technologies, and then maybe a “how it works” section for “all” of CanJS.

Anyhoo … thanks again for your feedback. We take it super seriously. I’ll be thinking about it a lot.

---

<div class="post-metadata">

**Author:** ![justinbmeyer](https://yyz1.discourse-cdn.com/flex035/user_avatar/forums.bitovi.com/justinbmeyer/32/179_2.png) [@justinbmeyer](https://forums.bitovi.com/u/justinbmeyer)\
**Post date:** [October 10, 2018, 5:18pm UTC](https://forums.bitovi.com/t/open-source-theory/975/4 "2018-10-10T17:18:52Z")

</div>

In terms of why someone should use CanJS, I’ve been thinking of stating that it’s probably the easist way of writing CRUD apps. As CRUD pages are 90% of what most people do, I think this might be appealing. I’m curious what you think.

Here’s some of the “evidence”:

### CanJS handles promises (with their state and errors) REALLY well

```auto
{{# if( todosPromise.isPending) }}
 Loading
{{/ if }}
{{# if( todosPromise.isResolved) }}
  {{# for( todo in todosPromise.value }}
   ...
  {{/ for }}
{{/ if }}
{{# if( todosPromise.isRejected) }}
  {{todosPromise.reason.message }}
{{/ if }}

```

In react, you’d have to make sure the promise is hooked up to call setState with the resolved/rejected value and have a whole bunch of boilerplate.

### The models make it easy to handle all those other weird edge cases

As models have a `.isSaving()` and `.isDestroying()` method, it’s easy to disable a button like:

```auto
<button disabled:from="todo.isSaving()">Create</button>

```

### It handles updating lists when items are added/removed/destroyed automatically

We call this automatic list management. When a “todo” or other record is created, updated, or destroyed, you don’t have to update the lists on your page. This works with pagination, filtering, sorting.

Here’s an example:

https://codepen.io/justinbmeyer/embed/preview/rqmWdP?height=300&slug-hash=rqmWdP&default-tabs=js,result&host=https://codepen.io

---

<div class="post-metadata">

**Author:** ![matthewp](https://yyz1.discourse-cdn.com/flex035/user_avatar/forums.bitovi.com/matthewp/32/77_2.png) [@matthewp](https://forums.bitovi.com/u/matthewp)\
**Post date:** [October 10, 2018, 6:08pm UTC](https://forums.bitovi.com/t/open-source-theory/975/5 "2018-10-10T18:08:16Z")

</div>

> [@Lighttree](#):
>
> many recipes and update them every time. So maybe it makes sense to reduce amount of recipes, but make them really great and “production” ready.

I wonder if we should just drop the DoneJS moniker. It might help CanJS, since it’s the most popular of our tools anyways, if people think they get all of the tools included with it. It would help with documentation too, if there were a Tools section on [canjs.com](http://canjs.com). Some of the donejs libraries are only documented in their readme which makes it hard to find the right documentation when working on a donejs app.

---

<div class="post-metadata">

**Author:** ![Lighttree](https://yyz1.discourse-cdn.com/flex035/user_avatar/forums.bitovi.com/lighttree/32/298_2.png) [@Lighttree](https://forums.bitovi.com/u/Lighttree)\
**Post date:** [October 11, 2018, 4:40pm UTC](https://forums.bitovi.com/t/open-source-theory/975/6 "2018-10-11T16:40:51Z")

</div>

Hi Guys,

Thanks for your super-fast response, didn’t expected that this brings so much attention.  
I’ll to answer on some points from your replies.

**Proposals.**

> [@justinbmeyer](#):
>
> Improve the homepage design and give a definitive reason to use CanJS

There is proposal that covers this part I think:

> <https://github.com/canjs/canjs/issues/4117>
>
> \_\_TLDR:\_\_ we’ve identified multiple issues with CanJS.com’s usability and we pro…pose addressing most/all of the issues below.
> 
> \> This was discussed on a \[recent live stream (10:57)\](https://youtu.be/coSEECcyi00?t=10m57s).
> 
> \## Motivation
> 
> We’ve conducted multiple usability studies that have given us insight into how people learn and use CanJS. From each study, we’ve determined things we can do to improve the site’s ease of use.
> 
> By addressing these issues, we think both new and existing users will have a better experience on our website.
> 
> \## The issues
> 
> As part of this proposal, we would address most or all of the issues below:
> 
> \- \[Improve the home page\](https://github.com/canjs/canjs/issues/4055)
> \- \[Improve the quality of the graphics on the Tech Overview page\](https://github.com/canjs/canjs/issues/4056)
> \- \[Add a Comparison to Other Frameworks page\](https://github.com/canjs/canjs/issues/2679)
> \- \[Fix navigating back after clicking a link to a specific section\](https://github.com/canjs/bit-docs-html-canjs/issues/449)
> \- \[Outline should not include headings within signatures\](https://github.com/canjs/bit-docs-html-canjs/issues/455)
> \- \[Make "Chat" and "Forum" buttons more clearly a means of immediate support\](https://github.com/canjs/canjs/issues/4096)
> 
> \## SEO
> 
> Additionally, we’ve identified some issues with our SEO. These are important to fix as part of the website’s usability because using a search engine is a common way for people to find content on the site.
> 
> \- \[Prevent pages with @hide from being indexed by search engines\](https://github.com/bit-docs/bit-docs-generate-html/issues/50)
> \- \[Generate better page titles\](https://github.com/bit-docs/bit-docs-generate-html/issues/44)
> \- \[Give each website page a unique description\](https://github.com/donejs/donejs/issues/1094)
> \- \[Fix the Google sitelinks under canjs.com\](https://github.com/canjs/canjs/issues/4074)
> \- \[Other CanJS.com issues\](https://github.com/canjs/canjs/issues/4079)
> 
> This proposal is focused on CanJS.com, but would have positive improvements on DoneJS.com and StealJS.com because some of the code is shared.
> 
> As a stretch goal, we could tackle issues on those sites as well:
> 
> \- \[Other DoneJS.com issues\](https://github.com/donejs/donejs/issues/1095)
> \- \[Other StealJS.com issues\](https://github.com/stealjs/stealjs/issues/99)

> <https://github.com/canjs/canjs/issues/4055>
>
> This is a collection of to-dos based on a recent UX study:
> 
> \- \[\] Improve the …quality of the graphic under \_Become an expert quickly\_
> \- \[\] Move the \_Extensions and Plugins\_ section above \_Flexible Programming Styles\_
> \- \[\] Show CanJS 4 in the graphic under \_Maintain your app over years\_
> \- \[\] Add something about the community under \_Maintain your app over years\_
> \- \[\] Make the header titles the same casing (i.e. \_Missing Something?\_ should be \_Missing something?\_)

So maybe we can just add more description or add reference to this thread there ?

> [@justinbmeyer](#):
>
> Create a “CanJS” version of the in-depth guide and emphasize that.

Created:

> <https://github.com/canjs/canjs/issues/4524>
>
> \### Proposal
> 
> This is about creating advanced CanJS guide same as \[DoneJS In-d…epth guide\](https://donejs.com/place-my-order.html).
> 
> \> This is based on forum discussion: https://forums.donejs.com/t/open-source-theory/975
> 
> \### Why
> 
> Main difference from existent \`DoneJS\` guide that I can think about is:
> 
> \* Presented on \[CanJS.com\](https://canjs.com/)
> \* Follows best practices in \`CanJS\` applications.
> \* Shows how \`CanJS\` application can be built from architecture standpoint.
> \* Covers same points as in \`DoneJS\` guide. (Almost all development aspects).
> \* Doesn't use \`DoneJS\` specific features.
> 
> \### Benefits
> 
> Main benefit is improve learning process of \`CanJS\` for newcomers and decouple it from \`DoneJS\`.

> [@justinbmeyer](#):
>
> Consolidate youtube and gitter channels

Created:

> <https://github.com/canjs/canjs/issues/4525>
>
> \### Proposal
> 
> This is about rethink how community and information channels are… organized.
> 
> \> This is based on forum discussion: https://forums.donejs.com/t/open-source-theory/975
> 
> \### Problem
> 
> Currently there are quite many small resources that people can use to get info:
> 
> \*\*YouTube\*\*
> Bitovi: https://www.youtube.com/channel/UC\_HPFLeKzJNLOUnLc\_3311Q 1 (310 subscribers)
> DoneJS: https://www.youtube.com/channel/UCEnTQUfJi0L6l7g8IRuaVkg (83 subscribers)
> CanJS: https://www.youtube.com/channel/UCM\_xC8UOHt2ay5wz-3gotmg (189 subscribers)
> 
> \*\*Gitter\*\*
> https://gitter.im/canjs/canjs
> https://gitter.im/stealjs/steal
> https://gitter.im/donejs/donejs
> https://gitter.im/bitovi/js-training
> https://gitter.im/bitovi/testee
> https://gitter.im/bitovi/funcunit
> 
> They are very granular. I think not all of them are used and information / community blurred across all of them.
> 
> \### Possible solution
> 
> What I was thinking about is, maybe it makes sense to have single \`YouTube\` channel that contains everything about "Bitovi technology stack" where you can arrange videos by different topics (series). Same way how \`"How it works"\` exists today.
> 
> Same can be done to \`Gitter\` channels.

> [@justinbmeyer](#):
>
> Create a best practices / architecture guide

There is such proposal, maybe we can just extend it with `Architecture`:

> <https://github.com/canjs/canjs/issues/3646>
>
> Inspired by \[this Slack thread\](https://bitovi.slack.com/archives/C09R50SAE/p150…8514592000534) @kylegifford posted: it’d be great for us to document the best practices we’ve come up with over the years.
> 
> Some ideas that were posted in that thread:
> 
> \- avoiding the \`events\` object (use streams instead)
> \- have the app component \`only\` deal with session + routing.
> \- use directional bindings where appropriate
> \- spend time getting your set-logic right (write tests for it)
> \- Write tests for the service layer and have that team run it if you can. You can use the same tests against fixtures if you need to.
> \- use custom events and attributes; the DOM has state ... expose changes in that state through custom events (usually setup via custom attribute)
> \- follow the modlet pattern

**“Advanced” CanJS**

> [@justinbmeyer](#):
>
> I’m a bit confused what to propose from the “Advanced CanJS” section. Would continue to add “how it works” sections to our docs help?

Yes I think “How it works” sections and videos definitely great stuff and It will be great if you continue with them.  
I think they can solve one part of this. Maybe it can be improved by some graphic / diagrams that presents information. Idea is that this is nice to have “verbal” explanation of how things works. I think React’s documentation is quite good in this term: [https://reactjs.org/docs/optimizing-performance.html#shouldcomponentupdate-in-action](https://reactjs.org/docs/optimizing-performance.html#shouldcomponentupdate-in-action)  
( Well `React` has less `API` that they need to explain of course ☹ )

Additional point here is that there is different goals that people may want to achieve:

- Some people need to implement small application fast that “just works” and fast.
- Others need to implement long-living apps that has good performance, scalable, maintainable etc.

Second result requires way more knowledge in how framework works, because writing something that “just works” not enough. This requires understanding of how to write CanJS better, how to split layers, how to split components, how to avoid / solve / improve performance (so you need to understand very clear what can affect this).

**CanJS expertise**

> [@justinbmeyer](#):
>
> I think providing someone this might be rather hard as CanJS has become so abstract over the years. To understand how `can-define` 's observability works, you need to know:
> 
> - How to satisfy `canReflect.getKeyValue()` with the `can.onKeyValue` symbol
> - Working with `can-queues` to dispatch elements.
> - Working with `can-observation-recorder` to work with computed properties.
> 
> Those “how it works” videos were my attempt at answering this question. But even once someone understands how the observables work, then to be really an expert, they will have to know `stache` . The core things about stache:
> 
> - can-view-target - the “compile target” of stache
> - can-view-parser - an HTML parser
> - can-view-nodelist - organizes the stache hierarchy
> - can-view-live - Able to keep part of the dom up to date with an observable
> - can-view-scope - the scope lookup construct of can-stache
> - can-stache - Includes a parser for expressions. Then uses both `can-view-parser` and its own expression parser to generate functions that result in a renderer.
> 
> I guess I see people can become experts, but I think it’s easier to become experts first at one part (observables) and/or another part (stache/view)

Yes, I agree that `CanJS` contains different parts that you need to learn and understand. So this point actually about all these things 🙂

You see, many packages that you mentioned above never used directly. We wrote around… 3-5 applications and never used directly something like `can-view-scope` because this is internals of `can-stache` so in general you won’t even click this page in `API` documentation. As result you have `can-stache` that actually used in code and lots of packages that works under the hood, but rarely used directly. Still you need to learn them and know about.

Yes “How it works” videos can be good place to cover them.

**Why CanJS great.**

> [@justinbmeyer](#):
>
> As CRUD pages are 90% of what most people do, I think this might be appealing.

Yes, I actually agree with you, when I passed through [DoneJS guide](https://donejs.com/place-my-order.html) after `CanJS 2.2.9` it was like a magic :D.

> [@justinbmeyer](#):
>
> The models make it easy to handle all those other weird edge cases

Maybe, but you need to learn how to _think_ in “CanJS way” first.  
I remember that dev from another team who had no previous experience with `CanJS` came to me one day and said:

> “I just want send `GET` request to this `URL` why its so hard in `CanJS` ? I don’t need model, I just want to get data.”

So… in general I know that `CanJS` can do good things, and it possible to be quite productive when you develop using this framework. But there is should be a way to explain this to others 😃

> [@matthewp](#):
>
> I wonder if we should just drop the DoneJS moniker. It might help CanJS, since it’s the most popular of our tools anyways, if people think they get all of the tools included with it. It would help with documentation too, if there were a Tools section on [canjs.com](http://canjs.com). Some of the donejs libraries are only documented in their readme which makes it hard to find the right documentation when working on a donejs app.

Well this is quite global decision, doubt that I can say something here 🙂 A lot of effort was putted to `DoneJS`, so it depends on how gracefully this can be moved to `CanJS`.

Best regards.