Hacker News Reader

Comment by mythz | Hacker News Reader

Abandonment is a risk facing any heavy "all-or-nothing" frameworks, not only is this bad for existing apps built on YUI, but it's also bad for developers skill set investments that will soon become obsolete.

It's hard to imagine heavy popular frameworks like AngularJS falling to the same fate, it would need something far superior with a lot of traction to displace it. But it's still a risk if you build your application the "Angular Way", "The React Way" or "The Ember Way", etc where if the primary developers halt development for whatever reason, your app dev stack becomes obsolete making it harder to attract great devs (who don't want to invest in a dying platform).

It's less of a risk with lightweight frameworks and libraries like Backbone.js where the code-base is so small and extensible, anyone can easily maintain their own fork. It's also less of a risk for WebComponents as the component model leverages the browsers DOM and lets you use modularized encapsulated components built with different technologies, so if one of the technologies ever becomes obsolete you can always start writing new components with newer tech and integrate it with your existing app, without having to rewrite it.

View on HN

> It's hard to imagine heavy popular frameworks like AngularJS falling to the same fate, it would need something far superior with a lot of traction to displace it. But it's still a risk...

To emphasize the "still a risk" part: Angular is only four years old, and its popularity is arguably only two years old. People are just barely starting to get a feel for the advantages and disadvantages of building the Angular way. There's some significant things to like about it, but there's absolutely no guarantee those things won't be subsumed into something else or devs won't decide some other way is better, either on the merits of careful thinking or enthusiasm for a fashion of the moment.

(If someone had told me 10 years ago, for example, that relational databases were soon to fall out of vogue for hierarchical/document databases or key-value stores, I would have said history seemed to be against them, but here we are.)

This is software, ephemeral foundations and vicissitudes are pretty much a given.

> (If someone had told me 10 years ago, for example, that relational databases were soon to fall out of vogue for hierarchical/document databases or key-value stores, I would have said history seemed to be against them, but here we are.)

I promise you this is some sort of bias you have. Relational databases are still used way more frequently than NoSQL databases, probably to the tune of 1000-10000 times more.

Relational databases are a more general-purpose solution, so have received far more attention historically and have already matured far beyond the NoSQL alternatives. NoSQL gets press because it's different from the mature alternative and so it's interesting, but it's also very niche in comparison.

Both solve entirely different classes of problem. There are functional overlaps for small problem domains, but as your infrastructure tries to do more, you may find a need to run several distinct lightweight services backed by a variety of datastores serving focused requests.

Many of you have already seen Kovacs' comparison of nosql stores. Just throw a SQL DBMS into the decision matrix. Consider how several might work together.

http://kkovacs.eu/cassandra-vs-mongodb-vs-couchdb-vs-redis

Fowler's microservice post is a decent introduction to the microservice architecture, which is more or less what I'm describing.

http://martinfowler.com/articles/microservices.html

Granted, this probably isn't how to get the MVP out the door. But once you grow, this architecture can prevent the formation of monoliths of pain.

Pretty much everyone who uses Postgres or MySQL uses Redis, so that comparison is not going to work.

Another crazy bias.

Those who don't learn from history are doomed to repeat it.

I feel like framing your comment and posting someplace where everyone else in my office can read it.

As a developer that still uses YUI on multiple production applications, I've never felt that my front-end skills were stagnating due to its usage. The same goes for ExtJs, which I have used heavily in the past. Both libraries allow you to create the models, views, controllers, templates, etc. And they both have notions of apps and routes. There might be a lot less magic going on in terms of getting data binding to work, but it's something javascript devs should understand anyways (loose coupling using custom events). I think the detriment comes more from newer companies looking to hire front end folks who have experience with modern frameworks such as angular, ember, and react. But there's also a lot of magic going on in those newer frameworks and libraries so when something breaks or you need to step out of the box, a deeper understanding of what's going on is usually good.

> it would need something far superior with a lot of traction to displace it.

Personally, I have found react.js to be much better than Angular but in any case I found your comment to be filled with a heavy use of unwarranted intensifiers ("far superior") and some amount of fortune telling.

Front-end development is a fast moving field, and the new ECMAScript 6 changes, as well as further browser updates, will probably shake up the scene, but it's hard to predict what will happen. I doubt that we'll reach a point of stability any time soon where you didn't have to throw out at least some decent amount of code after 5 or 6 years due to library changes and browser updates.

It's not an either or problem - you can use Angular with React. React does not buy you code organization for large apps.

Yes you can use parts of Angular with React, I don't think that's optimal, but you can do it.

>>Personally, I have found react.js to be much better than Angular

This is a tangent, but can you explain why?

I can't answer for the OP, but from my experience what makes React so good is that it drastically simplifies the whole 'situation' to the point that many of the features of heavier frameworks are just not necessary anymore. It's not just a view layer (although I can be just that); it's a different approach to the concept of a web app.

In my opinion the approach that React takes (as well as its siblings like Mithril and Ractive) will eventually be the default approach, even for the bigger frameworks (new or 'refactored').

For me react does one thing and does it well introducing clear architecture focused on composability.

Angular has some fair parts (testing, resources) and some really convoluted and what's more important bug ridden parts (directives and scopes).

Directives and scopes may be somewhat tricky concepts but they are not "bug ridden."

Do you want composability? Write a bunch of element directives and nest them -- it'll end up looking almost exactly like React's classes and components. The main difference is that in React you throw away MVC and replace with with a big ol' render() function that spits out "HTML" (well, a shadow-DOM version of it anyway)

Scopes are just objects that use prototypal inheritance to inherit from outer scopes. Create an new (isolated) scope in your directive to isolate data to that component and its subcomponents.

Also, using AngularUI Router is essential.

Sorry. After last two months with angular (and no previous experience with it) I found five bugs in angular. Fix for one was released in the meantime. Some already had fixes submitted months ago but got stuck on different stages of their process of accepting patches. One is not even reported yet (although I admit this one is not about directives but $ q).

As for composability they did not seriously thought this through. One bug I found out, the one that got fixed, showed up for anone who created two directives with isolated scope and transclusion, one used in template of the other. Basically isolated scope of outer directive got transcluded into inner one instead scope outer in relation to outside directive.

Scopes suffer from the same flaws that with() statement in js suffers mainly that when you assign inside it will be assigned not where you at first expect (current leaf scope not the scope of closest controller). When you add to this the fact that humble ng-model assigns you have a huge hole that nearly all newbies fall into at least once.

Another gripe is that angular doesn't eat it's own dogfood. For example ng-required is not a directive. It's just attribute parsed internally by input directive.

AngularUI router is worthless if you need to have multiple tabs inside your web app as it allows you to have just one branch of views tree shown at any given time. There are suggestions about implementing parallel subviews but last time I checked it was too hard for them.

Angular is set of legos with lots of weird pieces. React is blueprint how to make your own bricks so they fit together and won't turn into tower of ugly chaos when assembled.

I was distrustful towards virtual dom at first. But that's just a way of batching and saving dom changes. The architecture that's enabled by it is all about composability and maintaining control over your project.

Not every directive attribute needs to be another directive -- it's probably overkill, especially if the attribute applies to only on one type of element. ngValue is an example of dogfooding directives with more directives.

UI Router states are pretty tightly bound to the URL fragment path, which makes it difficult to point to all the parallel states that make up that particular view "configuration"

Say you have a page /foo that shows two sets of tabs, A B and X Y. To point to foo with tabs A and X open, you need put that in the URL, e.g. /foo/A,X, or express it as a state path foo.A,X. It gets even hairier if you then want to activate children of those states, e.g. A.a and X.x.

You could implement your own subview routing with ngSwitch and stateParams (perhaps query parameters). It's obviously not a great solution.

> Not every directive attribute needs to be another directive -- it's probably overkill,

I think that this particular example shows that rather than extending framework of directives to nicely incorporate lightweight directives such as ng-required angular team chose to hack it into input/select/textarea directive because it was easier that way for them. There are many places like that in angular where the hacky path was chosen and due to this, architecture is lacking some of very obvious features like one-way binding of expression given in attribute to isolate scope (which is what ng-requried does to get it's value). You need to use & as workaround to achieve one way binding.

As for Angular UI as I said there were people that wanted to figure out how to implement tabbed views but they got no love from core developers. Basically recent advice about using UI Router to implement tabbed app is "Don't".

So I just went to implement my own stuff with $route, $routeParams, $location and ng-include.

throw away MVC and replace with with a big ol' render() function that spits out "HTML"

Simply put, no. React.js can be treated as a simple, dumb view or part of something larger ala Backbone, Flux, etc..

Angular.js doesn't even have a model layer aside from $scope, which in my experience is being thrown away more and more in favor of controllerAs syntax & convoluted services masquerading as 'models'

Absolutely agree. I use it from clojurescript and its a dream to work with.

mind elaborating on what you liked about react.js over angular? I am guessing performance?

And inline JSX instead of separate template files. React is just very good at turning state into DOM elements.

FUD. Backbone is nothing but a bootstrap. It really just means that you evetually rely on literally twenty or thirty other "micro" JS libraries to get the same shit done that one framework could singlehandedly provide. Those micro libraries have a higher abandonment rate than anything.

Personally I'd go for company-backed projects.

Just a note about company backed projects. I backed Google Web Toolkit a few years back. Big mistake.

GWT is still being maintained, and I hear GWT 3.0 is on they way with a lot of great features.

The problem with GWT is that newer Google-associated projects are perceived by some people as better (and the comparison is not always apt): Web Components, Polymer, Dart, Angular, etc.

But that doesn't somehow make GWT any _worse_ than it was before, and it's still improving. The compiler is faster, they're adding Java 8 features like lambdas, the JS interop is better, they're tracking web APIs closer, and I think they have a even plan for web components integration.

I used to use GWT extensively, and I would be one of the ones to argue that it's approach was great at one time, and probably a bit outdated now, but it's not abandoned and it's evolving to fit better with today's modern browsers. I might not choose it today, but I wouldn't regret choosing it a few years back, or be in a huge rush to move off of it if I had a large codebase.

It's funny because although I regret using it to deliver products, I don't regret having been exposed to it as a developer. I learnt a lot about how to build well structured front end code by using it.

I still believe it's doomed though just because I don't believe they can match the pace of the JS world.

Why? This is not a troll, I'm very interested in your reasons.

As someone who has been working with GWT, and since moved to JS, I can elaborate on why I agree. GWT was an excellent tool when I started using it, but has been eclipsed (no pun intended) by substantially nicer frameworks (IMO). I am extremely thankful to be using it as little as possible, and am migrating as many of our GWT apps over into Javascript apps as soon as workload allows. (I'd LOVE to hear from someone who is currently using GWT, and has compelling reasons that it's a great tool that are not driven by the inertia of a large codebase.)

The main reason I'm glad not to use GWT is that I enjoy developing in Javascript a lot more than I do in GWT (Java). I have found that I can implement, modify, or troubleshoot a UI roughly an order of magnitude faster than I used to be able to do it with GWT. This is due to a combination of being able to reload by refreshing my browser (no slow re-compilation steps), as well as being able to inspect elements/styles directly in the Chrome dev tools.

There are about an order of magnitude (or more!) people who write about Javascript, or $FrameworkOfChoice (Angular, Backbone, etc) than there are that write about GWT. This includes both blogs and Stack Overflow, not to mention examples on JSFiddle or the like.

GWT doesn't easily let me integrate other Javascript libraries or components, so you have to implement your crappy version of Chosen (or similar) yourself. There's no JQuery or Underscore or similar, because it's all Java (basically).

The Chrome Dev Tools or Firebug are >>> the GWT debugger. The GWT Dev Mode plugins required for debugging, is also no longer supported in Chrome, and soon in Firefox. (I discovered this last week, the first time I've touched GWT in half a year. There's a newer Dev Tools alternative, but I've been unable to actually get it working.)

Javascript testing tools (Jasmine, phantomJS, etc) and build tools are now a MUCH more mature ecosystem than they were when GWT was first invented. We used to use a combo of JUnit + Watir/Selenium to test our UI, and now we can do similar with Javascript frameworks in a less fragile way.

In summary, GWT was awesome, but I see no reason to use it today. It helped me find my current job, so I'm grateful for that. However, if you were looking for a web framework, you would be much better served (IMO) if you chose React, Angular, or Ember rather than GWT.

I have used GWT on two from scratch front ends within the last 8 months.

All of your points are true and well written, but at the end of the day, I don't want to write and maintain large apps in JavaScript (or really in any dynamically typed language for that matter). GWT is still the best way to avoid that.

Have you touched on Angular in Dart? I agree with the value of typing, but full GWT just feels very clunky.

Sorry to hear you couldn't get it working. We're seeing about 5x compile time improvements in Super Dev Mode on trunk, but setup is not as easy as it could be. (It's being worked on.)

Well it's no longer "Google" Web Toolkit, it's now just "GWT"; they've handed it over to a steering committee.

At the time I loved using it as it had many nice features. But sadly it's very hard to migrate from. Most importantly is the vendor lock-in with the 2 framework specific RPC mechanisms used to communicate to the server.

Past bad decisions stay that's hindsight. In this case not so much the project but technology has become irrelevant. Technology changes every few years or even evey year. Nothing to do about that. Software is difficult.

'Company-backed' is a very nebulous term. If Microsoft was backing Angular I would have every confidence that it would be supported at least for security fixes for the next 10 years even if microsoft had to add a whole compatibility layer on there next 3 OSs to do so. Google backing an open source project on the other hand has a whole different level of support expectations in a 3 year timeframe.

just like Silverlight! :)

yeah exactly MS gave up in silverlight however they will continue to provide security fixes for it probably for the next decade

> Those micro libraries have a higher abandonment rate than anything..

> Personally I'd go for company-backed projects.

You mean company-backed projects like YUI?

Yes, when it was still relevant and heavily developed. So for a long time now I would've said chosen something else, more relevant to and convenient for modern-day web development.

Of course if you chose YUI a few years ago and you're still using and relying on it, that means it is still serving you well. Was a great past decision ay?

Yea but those microframeworks can also easily be replaced or re-written if they are abandoned.

That's true, but most companies need to spend at least some of their time on writing their own code and features too. So we pick third party code that serves us and saves us time.

Analogy if the goal is to go for a smooth car drive, why would you want to stop and be replacing/reinventing wheels every few minutes?

Obviously it's not black and white and you'll probably have to do a little of both.

I've been using Backbone for years without any micro libraries. I only recently started using React with Backbone, which is an awesome pair.

At the same time, a lot less is being abandoned--and your team is more likely going to be able to fight bitrot on a small microframework than on a huge thing like Angular.

Not having tons of libraries means that my team doesn't have to fight bitrot regularly though. Also bug reports / PRs are actually handled adequately by the bigger frameworks and their bigger pool of contributors, so code quality, which I find an important aspect of the software I deliver, is very much guaranteed.

I don't see much point fretting about bit rot. That's a murky future problem and there is little to guarantee the code we're writing today will outlive the libraries we're using. Instead what I care about is productivity and my experience as an engineer and engineering manager is that the simple, small, annotated source of libraries like Backbone and Underscore will beat the monolithic uber frameworks 9 times out of 10.

The trouble is that people often use examples of what you can accomplish with a framework if you follow the common path. But we've all been there -- a 20 hour feature where you build 90% of it with heavy framework support in the first 10 hours, then spend the next 10 fighting the framework for whatever it is that you need done differently than the framework prescribes. This blunts that seemingly-huge time save that a framework appears to provide when you watch a 5 minute build-a-blog screencast. So in the end, it comes, as it usually does, to mastery. The guy who has developed mastery over his tools will outperform, and I think it's a lot easier to master these small libraries with accessible source code.

For the record, one thing I like about Angular... I think the library tries to support existing/future technologies rather than define its own way of doing things. For example, the devs are planning that components can be 'exported' to WebComponents in Angular 2.0[1].

[1] https://groups.google.com/forum/#!msg/polymer-dev/4RSYaKmbtE...

I would like to point out, with regard to Angular, that they are moving to a much more lightweight delivery strategy. Their plans moving forward are to break out all the individual components into importable modules, and make Angular sort of a salad bar of functions. This should help mitigate the "all-or-nothing" nature of large frameworks. Hopefully it will also help make it relevant and compatible with new technologies like Polymer.

So essentially what Ember and React have done? Nice to see

> But it's still a risk if you build your application the "Angular Way", "The React Way" or "The Ember Way"

This misses the point. A good developer, in my mind, has the ability to adapt regardless of they framework they choose. The only risk is really the one who chooses not to adapt, regardless of the way their CV is positioned at any one point in time.

That being said, COBOL developers still get paid $100's of dollars per hour in today's environment due to legacy software holders.

The risk is more about supporting legacy applications and the inevitable bitrot, not so much developers.

if one of the technologies ever becomes obsolete you can always start writing new components with newer tech and integrate it with your existing app, without having to rewrite it.

This is the kind of snake oil that's been sold to developers for decades. We never (collectively) seem to learn.

The risk of abandonment is heavily mitigated by the project being open source. If an organization is heavily invested in a project that gets abandoned, they can always fork it and maintain it themselves. Compare that to what happens when a private company decides to kill a product.

Just imagine if jQuery stopped development. Obviously someone would pick it up but if they didn't there would be a massive number of frontend skill sets becoming out of date.

maybe i'm missing something, but I don't see jQuery as a massive skill-set investment. There is the selectors and the api, but it does overlap with a lot of other frameworks like underscore.js etc.. after switching it would be a matter of looking up the new syntax for a few weeks?

> skill sets becoming out of date

To an extent. None of the people I know who use jQuery regularly would have any trouble adapting. They might be unproductive for a couple weeks.

Large code bases that depend on jQuery seem like a bigger problem if for some reason no one was able maintain jQuery.

There are probably some quite old versions of JQuery running happily. The wonderful thing is that you can Google "jquery <insert problem here>" and get a good answer. This property would be useful for a long time to come even if better libraries evolved.

>but it's also bad from developers skill set investments that will soon become obsolete.

Why is it bad that developers will move from old legacy frameworks/libraries to newer, more modular solutions? I don't quite understand why someone would be unhappy to have to learn a new JavaScript framework.

> I don't quite understand why someone would be unhappy to have to learn a new JavaScript framework.

Because you need to learn that framework.

And the new packaging system.

And the new *SQL database.

And SASS, LESS...

And the new test framework

And another build tool.

And a new programming language.

And understand the business logic of the new client.

And sleep 8 hours, exercise, see your friends, spend time with your gf...

Modern web development could be overwhelming, I'm still young and willing to learn but I totally can understand why some people stick with "old" technologies.

i have a wife and 4 kids. i'm home to eat dinner with my family each day, i bathe my kids, i read to them for 15-20min before bed, i put them to bed, and then watch a tv show or movie w/ my wife. wife goes to bed, i usually stay up another 2-3 hours coding, reading, watching cosmos/st:tng, or something like practicing drywall mudding/taping. family first, then work, then sleep. w/ priorities clearly defined, i never have a problem deciding what to do (be it saying no to work at 6pm, or going back to office at 12am).

when i do read/code outside of work, i either focus on high level design pattern usage or on increasing knowledge of obscure js/css performance hacks. e.g. angular is dead-simple to write code for once you pay attention the patterns behind it instead of the conventions/syntax. otherwise it's a mess of hacked together code and googling for a better way to do what you're trying to do.

frameworks come, frameworks go. learn the foundations well and the rest of it matters a whole lot less.

Your post doesn't make much sense. You could use a new packagin system, a new *SQL database, SASS/LESS, a new test framework, a new built tool etc. even without letting go of YUI.

If you never want to learn anything new, then be my guest, but I don't understand those developers.

Besides, developers should learn new software all the time, not develop with YUI for five years and suddenly learn everything at once.

He's saying there's a lot to do and already a constant flux of other new things to learn. I imagine seeing your favorite library being deprecated could be frustrating?

But I would say to those people that if the maintainers of your favorite library are saying that there are better things out there, then you have reason to learn new things.

I agree it's a hassle, but don't you feel like this is a bit melodramatic?

This is why you should understand the language first.

A framework is just a tool to abstract some complex/repetitive tasks and work faster, but they're in no way a replacement for the language they're written in.

For example, jQuery.ajax(), you should not treat it as a black box, and pretend everything is done by magic.

You should at least understand the process behind it: Creating the XMLHTTPRequest object, setting the onreadystate event to check if the request was successful, etc.

If a feature brought by a framework is good enough, it will be added eventually to the language, ex. document.querySelectorAll().

Time spent learning new frameworks and "different approaches", is not spent delivering value to customers. Not to mention all the existing libraries/components accumulated in the years of simplifying building apps with it also become obsolete.

The value comes from the new "frameworks" being better than legacy. If YUI actually was better than the newer solutions, Yahoo! probably wouldn't claim that it's worse.

Experience in one context won't shift well and senior folks will seem junior, if not worse, for inserting non-idiomatic patterns into the newer solutions. Q: Where's my cheese? A: We don't have cheese here.

As a developer, it's always interesting to learn outside your scope of knowledge. As a product manager, it's a PITA to spend X hours for technical stuff that delivers no value to the clients.

> But it's still a risk if you build your application the "Angular Way",

That's not true.AngularJS allows a total an clean separation between AngularJS and your code through dependency injection.

It means that your code can be totally decoupled from the framework (even the directives).

That's not the case for Backbone,Emberjs and others.Their first sin is the use of Active Record,which means vendor lockin,and over reliance on inheritance (Backbone.Model.extend ... )

A few month ago I had to make some business logic work in a webworker,without duplicating it ,nor using angulars,in an angularjs project. Because AngularJS uses an IoC container,it just worked,the only thing I had to do is to manually wire up dependencies,but the same code worked without a single line of Angular code.

That's the most important difference between AngularJS and the rest,easy opt-out. And I really hope the javascript world begins to embrace inversion of control ,because frankly,i'm sick of all these spaghetti code apps, I have to maintain. Only AngularJS gives you the tools to write clean and decoupled code without verbosity.

Backbone and Ember suffer from the same "rail's way" problem.AngularJS is a good compromise between configuration and conventions without Active Record .

People often say Backbone is "lightweight" ,actually I think AngularJS is lightweight compared to Backbone,and that's why it is so successfull, with one lib, one gets everything one needs to build small apps as well as large apps,without all the boilerplate.

Your rambling incoherence makes your point hard to understand. So you're saying that there's no risk of vendor lock-in by relying on Angular's dependency injection, which isn't used by other libraries? Gotcha.

Edit: Oh and it isn't polite to write things like "That's bullshit", then come back and edit it out later on without flagging that you've edited your code.

I think he's referring to the tight coupling between the object system and the data-binding/dom-update mechanisms.

React and Angular are both able to avoid those.

> Your rambling incoherence makes your point hard to understand. So you're saying that there's no risk of vendor lock-in by relying on Angular's dependency injection, which isn't used by other libraries? Gotcha.

> Edit: Oh and it isn't polite to write things like "That's bullshit", then come back and edit it out later on without flagging that you've edited your code.

You look frustrated, you sound you chose the wrong framework then came here to complain about those who made a smarter choice. But you're not saying anything,other than arguing on the form.

Not really. I use Angular. A lot. I'm not so convinced that it is an "easy opt-out".

You're living in a pipedream if you think you can easily port an AngularJS app to another heavy framework like Ember or React.

Depends how well built your application is. Good luck porting a crappy Angular app over - good engineering probably trumps choice of frontend framework the most.

Do you have any recommendations for good IoC containers for JavaScript, specifically node.js? I've looked at several and their are their far too complicated or not polished.

Architect[1]

[1] https://github.com/c9/architect

Unfortunately, that's not pluggable into an existing application. I was hoping for something that could be added to an existing application easily.

Reply on news.ycombinator.com