What is Reddit's opinion of ember.js?

From 3.5 billion Reddit comments

When you respect semver, if the main big daddy number changes, it means breaking changes; it means that it can basically be a completely new framework for all the project cares.

Why? Why are they creating a backwards incompatible framework every 6 months? What are they expecting their userbase to do? Relearn a new framework every 6 months (me_irl) or just stick with one of the versions and get angry at clouds?

In this case Ember's release path seems much saner... or like, most other libraries out there.

I'm assuming /u/SpiceFinger means the live binding script tag insertions with metamorph. It would inject script tags around bound values.

Here's the documentation about it.

Check out the Self Control App.

I'm a 3rd year Software Engineering student, and feel the same way honestly. Impostor Syndrome is a bitch.

Seeing as that you're already fairly far along, finishing your degree would be beneficial even if you don't go into the field. I recently found Ember.js, and have been having fun using it. I'm sure there's something in CS that might be somewhat interesting to you, and that if you do in your spare time will add value to all of that seemingly nonsensical data structures/circuits/binary/operating systems work that we all have to do.

I've found that on weeks that I work out regularly I end up being a lot more productive/happier when it comes to studying. Maybe start working out or pick up a sport (BJJ?) that will zap away some of the restlessness that plagues us all.

Whatever you do, I'd suggest that the devs don't dive into the RFCs or discussion forums (discuss.ember.js, Slack rooms) too hard for a few weeks, because so much is being proposed and thrown around that they can get even more frustrated.

It's frothy: like a keg in college where you ask for beer, they pour you a cup of foam, and you have to wait for a while to actually get the substance back, or you'll just get pissed at yourself for drinking empty bubbles.

I suggest the 2.0 books, the 1.13 guides (new as of yesterday) and the blog post explaining the difference: http://emberjs.com/blog/2015/06/12/ember-1-13-0-released.html

Once you've all gotten a handle on Ember then the "real-time" discussions are very interesting and you can relate to people's concerns, but until then I'd only use them for asking your own specific questions. Maybe one of us pedantic Ember veterans might tell you it's already been answered somewhere, but with everything moving so fast you're better off ignoring any solution you see and just re-asking.

if you PM me I'd happily chat about Ember (and "stir down that froth"). Unless we find out we're competitors in which case ActiveX is definitely the way to go.

Don't know how experienced you are with Ember, but it may help to wrap your updates in an Ember.run, so it doesn't try to update the DOM a million times.

http://emberjs.com/guides/understanding-ember/run-loop/

you can configure how much those changes break things with feature flags:

http://emberjs.com/guides/configuring-ember/feature-flags/

it's been quite helpful when converting older code. just flip the flag to keep your app working, then flip it back when you've converted to the new style. which changes/versions are you referring to? ember has kept pretty strongly to the semantic versioning standard, so when they release a major version or even minor version upgrade it's expected that some APIs will change...but like i said with feature flags you can remedy a lot of those problems centrally, with the framework itself.

Ember publishes a security policy here: http://emberjs.com/security/ and we've exercised it several times in the past (we are the only JS framework doing this). There is no explicit policy for backporting a security patch, but we often backport as far as we can given the nature of the problem and the fix. This has usually been around three releases back.

Ember.js 1.0 was released two years ago in 2013. Our APIs are nearly completely backwards compatible. We take semantic versioning very seriously.

For any breaking private API in 1.x, we issued a deprecation warning in the previous release. For any breaking public API change in 1.x, we issued a deprecation warning as soon as felt appropriate and kept the old API until 2.0. For 2.x we've improve the tooling (and will continue to improve it) around deprecation notices, and plan to support things like ignoring a deprecation until the release immediately before it is changed.

Tell us moar! Is it named after the city in Pinellas county, Florida? And will there be the obligatory TodoMVC implementation?

Seriously though, it would be very interesting to hear your ideas on where this sits in relation to Vienna and Ember. With Vienna being the original Opal MVC framework, and Ember being state of the art in javascript-land today, I think these two form a nice axis along which to place Clearwater, its features, design choices, advantages, disadvantages, etc.

Looking at this right now it's not clear if Clearwater is a toy project or the beginning of something huge. I see other attempts so far (both Vienna and Volt) not really getting off the ground. Vienna looks just way too basic, and Volt being tied to Mongo and trying to be a Meteor for Ruby (that's like so two years ago already). And whatever RubyFire is supposed to be - no one really knows (RubyVapor?). So, the point of my mini rant is: thanks for sharing, but don't get our communal hopes up with this thing unless you really mean it! :)

Ember makes it pretty easy to have loading. You can create a global loading template or have separate templates for specific routes or sub routes

http://emberjs.com/guides/routing/loading-and-error-substates/

I'd describe the dependency detection as "magic", but not leaky. It's pretty clear what happens (even if it's not clear how it happens), and I'm not aware of any edge cases where it exhibits surprising behavior.

I'm not generally a fan of magic like this, but I had previously used Ember, so I saw what happens when you strip the magic out. When I saw what Knockout had done, I spent like a week trying to find the edge case that would break it. I couldn't find one. In the end, it seems like a solid implementation that eliminates a lot of boilerplate (without going all the way to needing a preprocessor).

I dunno, if people are willing to accept something like JSX, I don't see why Knockout's computed observables are contentious.

I would use ember-data to fetch your data if you're not doing so already. Once you have the data in your controller or component you could just use a computed property to sort it.

I wrote a very simple computed macro addon that is great for immutable sort orders: https://github.com/workmanw/ember-computed-sortby

You can also use the built in sort macro if you want to be able to mutate the sort order (http://emberjs.com/api/classes/Ember.computed.html#method_sort).

No, I'm upset because things stated in several official blog posts have been delay indefinitely.

See: http://emberjs.com/blog/2015/05/24/another-two-oh-status-update.html#toc_routeable-components

> It is extremely likely to land in 2.1, or 2.2 at the latest.

That is one of the reasons I'm upset, because of the routine broken promises.

Routable Components isn't even being worked on, at all. Improved Pods only exists in an RFC.

Ember core team cannot ship features. They create these massive features to generate hype and they fail to deliver. And instead of trying to be practical and deliver things in pieces, they've held back on doing anything. Leaving many of us just hanging in the wind.

And if you use a framework (such as Ember or Angular) you don't need to worry about these things at all. I personally haven't used angular, but I know ember takes care of every one of these pain points for you.

I wouldn't recommend using the canary branch. Not for a soon-to-be production ready project.

Obviously converting {{component}} to <component> is trivial. But to avoid rewriting a lot of code, you should use the new get/set properties. In that way you can more easily control the flow of the application. :-)

It's described in the Ember 1.12 release in the third code block: http://emberjs.com/blog/2015/05/13/ember-1-12-released.html

I made a list of some good tutorials. But I agree with babinho, create a few applications. It's the best way to learn.

If you need help feel free to reach out here! Also check the official documentation it's great.

Loading session state before rendering sounds like a job for initializers, http://emberjs.com/api/classes/Ember.Application.html. Call deferReadiness, do your Ajax call, call advanceReadiness in the Ajax callback.

If you read those two books, the knowledge now acquired would be "pure JS" (in my opinion)

And if you want to learn a framework after that, my recommendation would be Ember if you want to avoid "JS fatigue" and "build tools fatigue" and "trying to make 200 modules work together fatigue" and "I learned this framework but the new version of this framework is making me refactor all my application and everything is broken and I don't even know where to begin fatigue"

Their aim is to match every Ember native tool to the same version. This means if Ember.js is in 2.4, expect to have an Ember data 2.4 and Ember CLI 2.4 to be released soon.

http://emberjs.com/blog/2015/06/16/ember-project-at-2-0.html

I think the important thing to note here is that Facebook was built in PHP because that is what Mark Zuckerberg was comfortable in using.

He was able to leverage his knowledge of PHP to build the product he desired.

Granted, the case mentioned by OP is a bit different as he is looking for freelance work. However, if you can build what clients expect, then I'm not sure it matters which languages and stack unless they are looking for it to be made with a certain language and stack.

Someone here mentioned that major projects will have multiple employees dedicated to certain areas in the stack. With that said, I would argue that MEAN (or another variant taking advantage of Node.js) will better enable you to develop minimally viable products on your own as opposed to other stacks. Take a look at Meteor and Ember.js.

Ember computed properties are very powerful: communities: Ember.computed.filterBy('model', 'isCommunity')

filterBy can take an optional value, otherwise will match the value true.

http://emberjs.com/api/classes/Ember.computed.html#method_filterBy

Well, you could start by outlining the structure of the site you want to build. Then you can create a rough sketch of each page. The more details you can put into the sketch, the better. Once you have sketches for all the pages on your site, you can start looking into what technologies and architectures(like MVC, MVVM etc) you can use to bring that sketch to life. Bootstrap would be sufficient if the pages of your site have similar layouts (like [header] -> [content] -> [footer]). In the site you've posted, they've added custom styles on top of the bootstrap theme. Most of the widgets you can see on the landing page are custom widgets. So if you're looking to build a site similar to that, bootstrap alone wouldn't do the trick. The next step for you would be to explore other technologies, for both the server-side and the client-side. For client-side, I suggest you look into Backbone.js or Ember.js frameworks. Hope that helps.

Geez. Ember documentation is still horribly out of date, it took me way to long to find this, but anyway: You might want to update computed property syntax from fullName: function () { ... }.property('firstName', 'lastName'),

to the new Ember.computed syntax:

fullName: Ember.computed('firstName', 'lastName', function () { ... })

Or even with getter/setter syntax:

fullName: Ember.computed('firstName', 'lastName', { get: function () { ... }, set: function () { ... })

Since the old syntax is planned to be removed. http://emberjs.com/blog/2015/05/13/ember-1-12-released.html

"This also aligns Ember's API with JavaScript getters and setters, and simplifies the path towards using JavaScript getters in Ember 2.0, after IE8 support is dropped"

React doesn't have a hard dependency on GraphQL in any way. You can use any data layer such as Orbit.

Another thing to look at could be Ember which is pretty easy to get started with.

Beware: this method uses Ember.View, which is deprecated as of 1.13.0. This link might serve as a bit of a guide on how to migrate it toward a component-centric approach.

You can use http://emberjs.com/api/classes/Ember.ObjectProxy.html to solve this. You return the proxy object and then when your promise resolves update the content property of that proxy object.

See http://discuss.emberjs.com/t/how-to-resolve-a-promise-within-a-template/6929/2?u=opsb for an example

If you're building a chat app, you almost certainly want Volt. Your Rails equivalent is going to be two apps: one Rails app implementing a back-end API, that's used by the second, front-end app in Clearwater (if you'd rather write Ruby than JavaScript) or Ember if having a completely different language and architecture for your front- and back-end apps doesn't scare you (yet).

If you're struggling with these kinds of things, it's worth reading this page in the guides:

http://guides.emberjs.com/v1.11.0/understanding-ember/run-loop/#toc_what-scenarios-will-require-me-to-understand-the-run-loop

There are also utilities for debouncing and throttling: http://emberjs.com/api/classes/Ember.run.html#method_debounce http://emberjs.com/api/classes/Ember.run.html#method_throttle

If you're familiar with Python and want to stick with that, look into Django. If you want a more cutting-edge website, check out JavaScript frameworks like Ember js or Angular js. You could create an API using Python and then do all the front end code using a JavaScript framework.

Another option is using Node js for the backend instead of Django/Python. That way the frontend and backend are in JavaScript and you only need to learn a single language. I'm currently working on a project using Sails.js and Ember.js (using the SANE open source project) to create a dynamic single page application. Sails runs on Node and adds the ability to quickly generate an API without having to write much code. So far it's been really easy to create functionality that would take a ton of time in ASP.NET MVC 5. It results in a lot less code too.

Ember js: http://emberjs.com Sails: http://sailsjs.org/#!/ SANE: https://github.com/artificialio/sane

Oldie but Goodie. Interesting in the article is a list of who uses the following:

> * Companies Using Angular > * Companies Using Backbone > * Companies Using Ember

> I'm sorry, what? Did I miss something? You better not be messing with me.

HTMLBars landed in the 1.10 beta or, to be more precise, can be used without modifications. The blog post contains the instruction to use it in ember-cli.

If you want a framework that holds your hand, Ember.js is your best choice. It's a very good framework, but be aware that you are locking yourself into using it. It very heavyweight, and isn't really designed to be embedded into one or two pages as you need it. It's designed to be your entire front-end application.

If you're okay with that, it's a great choice. But do you really need something that heavy?

http://emberjs.com/guides/configuring-ember/disabling-prototype-extensions/

"This is the extent to which Ember.js enhances native prototypes. We have carefully weighed the tradeoffs involved with changing these prototypes, and recommend that most Ember.js developers use them. These extensions significantly reduce the amount of boilerplate"

My current project is a fairly small API written in Go, but that's mostly because I wanted an excuse to play with the language. The last major work I did was an Ember backed by the <code>rails-api</code> variant of Rails.

You're currently data-binding the value attribute of the input to a property scaledDistThreshold. It sounds like what you're looking for is not so much the mouseup event (you don't care about mouseclicks, and you probably want to handle keyboard events changing it), but rather the value changing.

You can do that by taking advantage of the fact that Ember.Object (and Ember.Controller, etc.) is an <code>Ember.Observable</code>. You're probably looking for something similar to:

thresholdChanged: function () { // Do stuff with the changed value, such as saving it to a server // this.get("scaledDistThreshold") }.observes("scaledDistThreshold")

See for a rough example: http://emberjs.jsbin.com/dahahoje/2/edit?html,js,console,output

Also, you might benefit from reading the Ember.js Object Model Observers guide.

Nice try, but I went into software so that I wouldn't have to sell things :P

Honestly, they are both great frameworks. My comment was strictly based on my opinion of Ember's docs. At work, we are actually planning on using Angular for an upcoming project.

I come from a background in Ruby on Rails and the devs who made Ember are also contributors to Rails... so when I look at Ember I see a lot of similar design decisions that appeal to me - and I'm assuming anyone coming from Rails.

You can do google searches all day long for ember vs angular and you'll get a million different opinions. They are both very good at creating large scale js apps. I just feel that there's so much hype around angular that ember gets overlooked too often.

Back to the docs, check this out:

angular.bind

ember.Binding

Which one seems more intuitive and descriptive to you? Who knows, it may be angular, but for me it was ember. I actually built a small app a couple of weeks ago using just Embers documentation without having to turn elsewhere.

Here's a hilarious video of angular vs ember

(Keep in mind that this event was in no way a serious competition between the two - it was very lighthearted and meant for entertainment. Tom Dale is also a writer of the Ember framework so Rob is a little outmatched)

It is definitely nice to chat about this stuff as know one I know in real life has any clue. I agree that SASS and LESS are pretty much equal and which to use is completely personal preference. I used SASS because the Omega 4 template I was using in Drupal when I was first learning used SASS.

http://emberjs.com/guides/getting-started

I have found this to be a pretty good starting point for javascript and the client side MVC model in general.

Ember is always looking to improve their documentation http://emberjs.com/guides/ and would gladly accept contributors! https://github.com/emberjs/website

Also, I read a blog post from Mozilla this morning about their Firefox 29 release and they asked for documentation help https://developer.mozilla.org/en-US/Firefox/Releases/29

> "Want to help document Firefox 29? See the list of bugs that need to be written about and pitch in!"

I've actually used Backbone in projects that I'm still maintaining for customers. I find myself leaning towards Ember.js now since it eliminates a lot more boilerplate and the object model seems to make more sense to me.

If you want to really see the difference, just view source through the standard todo sample in both frameworks. Ember is simply - cleaner.

For reference: Ember todo sample and Backbone todo sample

You want an SPA framework that comes out of the box with routing, views, models, state management, etc? One that's long-lived and stable, but still maintained without stagnation? You want http://emberjs.com

If this information on the Ember Site is accurate, then Ember 2.9 (with Glimmer 2) will be shipped on the 17th of October 2016 (is in beta5 at the moment)

Edit: Added the year for when this post is read far in the future!

I'm not saying Ember will or won't rise to meteoric success. However, I would note that Ember has been receiving a little extra push recently with some additional free training available, the announcements of LTS, and some podcast support. Again, not insanely huge and it may not even really matter, but I don't think it is right to diminish the framework. It's a matter or best tool for the job; with Angular 2 not being primetime ready yet and Angular 1 facing a sunset eventually, there's plenty of room for other options.

It's also got some high-profile users: http://emberjs.com/ember-users/

So while it may not be talked about in the super-hype that is quickly becoming framework fatigue, I think Ember will likely stick around in the same way Backbone is still used.

It is not a different syntax for observer, it operates on different semantics.

Like React, the new Glimmer engine in Ember since 1.13 has idempotent re-renders via a virtual DOM diff. This new rendering strategy means that every time new attributes are passed into the Component, Ember can diff the changes, re-render the entire Component, and only update the parts that require updating.

When any new attributes are received (they are the equivalent of props in React terminology), the Component's didReceiveAttrs hook (one of many new hooks) fires, and you can handle the changes in there. Unlike an observer, this hook does not watch specific attributes. It will always fire when any one of them changes.

Edit: After looking at this on my computer and not from my phone, it looks like the jQuery $.when doesn't take an array, it just takes multiple arguments. In that case looks like you could do: Ember.$.when.apply($, [promise1, promise2])

http://stackoverflow.com/questions/4878887/how-do-you-work-with-an-array-of-jquery-deferreds

OR the Ember way using Ember.RSVP.Promise (recommended):

http://emberjs.com/api/classes/RSVP.Promise.html

http://stackoverflow.com/questions/19331835/request-two-models-together

Here you'd use Promise.all (or Promise.hash if you'd like)

eh, it's just refinements on how view objects are constructed and used. Components are just more isolated and reusable views than Controllers (and do away with the odd Rails legacy of calling views controllers). The interfaces are not so different between the two. As you become more experienced in any Javascript framework, it's simple enough to make the leap from one way of constructing views to another.

You can compare the Controller interface to the Component interface. Many methods and properties are the same. Components add events they can react to.

For now it's an extra layer of complexity to have to deal with both Controllers and Components. But none of the Javascript frameworks have settled on anything that's completely clean, robust and feature complete. They're all undergoing metamorphosis in every major releases to attempt to encapsulate both ease of use, reusability and flexibility.

Read the change notes on the ember site.

2.0 isn't a grand rewrite or anything, it's mostly just a bump in version numbering. Most of the backwards incompatibility comes from removing old cruft in the framework. If you're new to Ember you can start with 2.0 no problem, as long as you're following new-ish documentation.

The only conceptual change between 1.0 and 2.0 is that Controllers are being phased into Components. In 2.0 there are Controllers and Components, in the future there will be only Components (Ember 3.0?). The terminology in Ember is a fairly confusing, but with Controllers being renamed to Components it makes a little more sense?

Ember.RSVP.hash returns a promise:

http://emberjs.com/api/classes/RSVP.html#method_hash

> RSVP.hash is similar to RSVP.all, but takes an object instead of an array for its promises argument. > >Returns a promise that is fulfilled when all the given promises have been fulfilled,

>I was unaware of the 2.0 update

There's already plenty of great answers regarding your question, so I just wanted to address this. The javascript world moves at an incredible pace; I highly recommend trying to keep up-to-date with the ecosystem so that more changes like this don't blindside you.

Twitter is a great place to start, I recommend following everyone on the Angular core team as well as contributors to other frameworks e.g. the Ember.js core team. Not everything they post will be directly relevant to you, but it's great to have a pulse on the direction the javascript community.

http://emberjs.com/list-view/

List view is for lazily rendering long lists for performance improvements. Never used it but from what I gather, if the item in the list isn't visible then its not inserted into the dom. I had forgot about it and was surprised to see it mentioned in the blog post.

I think that's because of this blog post on the official Ember Blog where Yehuda highlights that the core projects (Ember, EmberCLI, Ember Data) will go hand in hand from this point on. And will have essentially the same versions.

"Starting with Ember 2.0, we will coordinate every release of Ember with releases of the main ecosystem tools maintained by the core team:

• Ember CLI
• Ember.js
• Ember Data
• Liquid Fire
• List View "

Many websites today are created with javascript frameworks like Angular and Ember. So if javascript is disabled these sites won't work. If your target audience primarily uses non-smartphones or really old computers, you should probably not use javascript on your website. Otherwise you will be ok you use it :)

Is it me or does the demo have a memory leak? I was watching dev tools and the heap is constantly going up. That's no bueno. I'm still very excited though.

Edit: it's a known issue: http://emberjs.com/blog/2015/05/05/glimmer-merging.html

The best place to learn all this stuff is the official blog. Every time they do a new release (every 6 weeks I believe) they post a blog with changes, and often go into a lot of detail about what went into those changes. The blog is here:

http://emberjs.com/blog/

and specifically the post about HTMLBars and the ember-template-compiler.js file is here:

http://emberjs.com/blog/2015/02/05/compiling-templates-in-1-10-0.html

Check out Backbone.js. It's not really a framework but a library that provides basic structure: models, collections, views and router. It integrates nicely with REST APIs.

If you're new to JavasScript, I think it's better to start with simple libraries / frameworks than to jump straight into bigger frameworks like AngularJS or Ember.js. You'll learn a lot more of the language and understand better the value of different options.

I tend to distinguish between the tutorial and the rest of the guides.

Which events aren't firing on touch?

Views are still part of the framework, and are used in a lot of production code, so I personally think it's helpful to have them detailed in the guides. When they're deprecated, notes will be added, and the tutorial will be updated. Probably just fold most of it into the components section.

So yes it is true, setting a computed property will remove the "computed-property-ness" of it. That is, unless you take two parameters into your computed function, if your computed property takes parameters, Ember will instead call your function when 'set'. This allows you to do some really interesting things. I think your problem can be solved like so:

http://emberjs.jsbin.com/ciwifajaze/1/

http://emberjs.com/guides/object-model/computed-properties/#toc_setting-computed-properties

Based on this it looks like you can use ActiveModelSerializers with rocket_pants.

You could then use the built in DS.ActiveModelSerializer to have Ember-Data play nice with your JSON structure.

While I haven't tried this myself, it seems like it would work. My only concern is if rocket_pants will embed the results from AMS inside of the "response" key of your JSON structure or fully replace it (what you want).

Along those lines, there is also Ember.js. I'm a designer with a pretty good grasp on HTML/CSS, and using EmberCLI, I was able to get a little blog running in 4 hours...granted I had some help.

Gitub has tons of open source things you might be able to use. I have a feeling something very similar is out there, and you can just adapt it with a few changes. Maybe start with that.

The Ember.js website has a self-submitted list:

http://emberjs.com/ember-users/

NBC News, Freshbooks, McGraw Hill, and Yahoo are a few others off the top of my head.

At a large company you are likely to find a number of different JS frameworks in use, just as you would find a number of backend technologies and languages.

Yes. The fact that Angular would make that kind of change is crazy as there is no upgrade path. So far, there's always been an easy upgrade path for ember apps. (Since 1.0) and from what Yehuda and Tom say, it's going to stay that way.

Many large companies are using it for their large scale long running apps. ZenDesk, Heroku's new dashboard, Vine, Discourse, Square, Yahoo, etc. More here: http://emberjs.com/ember-users/

Those companies aren't planning on rewriting their apps from scratch anytime soon.

I haven't looked at your code yet, but I was looking at this topic the other day. You might get something from reading this, if you haven't already. > http://emberjs.com/guides/routing/specifying-a-routes-model/

To paraphrase a few lines from the "asynchronously loading models" section, you would benefit from issuing a "promise" on the model hook, that tells Ember to wait for the data to come in before it renders the model with data. Until then, you've got empty fields being rendered, so the application doesn't hang up waiting, or do whatever weirdness you're experiencing.

Specifically, looking at this:

App.PullRequestsRoute = Ember.Route.extend({ model: function() { return Ember.$.getJSON('https://api.github.com/repos/emberjs/ember.js/pulls'); } });

It looks and feels synchronous, but its waiting for jQuery to load the JSON data from the API. Also, the linked to "A word on promises" in that article is good: > http://emberjs.com/guides/routing/asynchronous-routing/#toc_a-word-on-promises

You might get some mileage out of it. Hope that gets you somewhere.

You could try starting here: http://emberjs.com/guides/models/connecting-to-an-http-server/

If you're using rails and active models, then you'll want to serialize them to json using Active Model Serializer: https://github.com/rails-api/active_model_serializers/tree/0-9-stable http://emberjs.com/api/data/classes/DS.ActiveModelAdapter.html

Could be the metamorph script tags that are inserted around the pictures: http://emberjs.com/guides/understanding-ember/keeping-templates-up-to-date/

You could try using Ember 1.8.0 beta, which no longer uses these marker tags.

It can be kind of hit or miss. I imagine it's particularly bad when it's not US daytime hours. I think a big issue is that most of the people who are very good with Ember are busy doing stuff like developing Ember, so you're stuck with just a few people active in the chat who can help beyond very basic things.

People can't help you if they don't know the answers. Ember Data is a hot topic, but DI outside of the basic Controller needs API isn't used that much. Routing is in every app, but routing problems can be very simple or very tough to solve, and if you're not an expert, they can all look the same. It's likely people just had no idea how to solve your problems.

The guides are pretty good, and will answer most basic questions if you have the patience to read them front to back. It's a lot, but it's worth it.

If you never got your issue worked out: http://emberjs.com/guides/understanding-ember/dependency-injection-and-service-lookup/

I think you're trying to understand too many things at the same time.

I suggest you follow a guide (for example http://emberjs.com/guides/testing/unit-test-helpers/) about automated testing of emberjs apps. Try to get a basic test suite running with the frameworks the guide suggests.

Get to know the frameworks in your list as you run into limitations or annoyances.

This approach will give you a better idea of what frameworks you'll actually need (to know) and which ones you can safely ignore.

> Ember itself barely hit 1.0 a couple of months ago...

A couple? Ember 1.0 was released on August 31st of last year (http://emberjs.com/blog/2013/08/31/ember-1-0-released.html). That's A few days shy of 9 months.

Ember has a lesser known, but equally effective way of creating modular components - called Ember Components: http://emberjs.com/api/classes/Ember.Component.html

Here's a neat comparison of an angular directive and an ember component: https://twitter.com/heyjinkim/status/387362357124423681

There's a difference between redirect and beforeModel. As I understand from the redirect docs it's called around the same time afterModel is called and I didn't want that behaviour. I wanted to transition as soon as this route gets entered so beforeModel seemed like the best place for this job.

Please do correct me if I'm wrong :)

Surprised nobody has mentioned the redirect hook.

http://emberjs.com/guides/routing/redirection/#toc_after-the-model-is-known

It works the same as the afterModel hook, but semantically it's nice to put your redirect logic here.

I may be misunderstanding what you mean, but I believe the basic handlebars example shown on http://emberjs.com/ under "Auto-Updating Handlebars Templates" does exactly what you said it can't do? Unless you mean you can't have and expression (Like post.created_at - now() or something) in a handlebars template?

Also, I find it interesting that you can say with surety that angular is better when you say you don't know about about ember...

Not too familiar with Sproutcore but that looks to be a full-fledged development environment like ExtJS or Google App Engine, something that provides a framework for you to configure.

AngularJS is more of a tool than a framework, you use it to glue together the DOM and the whatever the server renders. It's more comparable to BackboneJS or EmberJS. Things you'd have to basically build from scratch to interact with the server. (Though AngularJS plays really nicely with NodeJS and Express)

I think the way you did it is good and I'm not sure that Backbone really makes it easier to read. But if you want to use Backbone with coffeescript maybe this will help http://adamjspooner.github.com/coffeescript-meet-backbonejs/

Basically it can wire the events for you and stuff.

There are also plenty of people using Ember.js with CoffeeScript. http://emberjs.com/

Not sure if Ember.js is really going to help particularly in this case because your thing doesn't really have a data model really and I think that is where Ember is most useful.

Thanks! The site is built on Rails which isn't known for its performance but the interactivity runs on Ember.js which I've been really happy with. Highly recommend checking it out if you ever write apps with lots of JS. http://emberjs.com

For those like me who had idea what Ember.js is:

> Ember is a JavaScript framework for creating ambitious web applications by eliminating boilerplate and providing a standard application architecture.

http://emberjs.com/