So I don't think there will be horror stories with Angular 5 for new projects, unless you just don't like Angular/TypeScript. It's definitely not like "going the wrong direction" from Angular 1.x, although I don't personally have any read on how it compares to Vue, or React, or Aurelia or what have you.
I also haven't gone through a 1.x→modern transition (yet), so I can't really speak to that, but in preparation for doing it I've read everything I can, on this forum, various blogs, etc.
I'm not looking forward to it, but on the other hand part of me thinks of course it's easier, or at least more fun, to move to something like Vue, because it's like a rewrite, or half-greenfield project.
It's almost always more fun to rewrite something, although usually not advisable from any other business perspective.
We don't see as many people talking/blogging about Angular anymore, but I think that's mostly because it's gotten boring. Which can be a good thing.
Thereafter though, they have been just relentlessly polishing, improving, smoothing rough edges, making bundle smaller, making compilation and execution faster, etc. It is really a model of exactly what you would want, in terms of a joint respect for backward compatibility with forward progress.
I don't understand the "haters" in some peer comments. There are certainly interesting things to consider in terms of feature and approach differences between Angular and its competitors. You could certainly find bits where a simpler approach taken by one of the competitors is a quicker learning curve and smaller size.
But at the same time Angular has a substantial feature footprint, it has significant swaths of functionality that the competitors don't address. We've been using (leveraging like crazy!) the Angular forms system. Many enterprise and non-enterprise applications have lots and lots of forms. Not forms in the trivial sense of, some controls on the screen. Complex interconnected behavior. Angular brings a lot to the table here.
On the flip side, I have found I missed some things about Angular that I don't have with libraries like Ember and React - Angular has the superior testing story for ability to control granularity of testing without sacrificing architecture. Complicated pure functions can be tested with ease in Angular due to its injector, but painful in other scenarios because one cannot easily mock out dependencies so easily or requiring some fairly poorly documented/written about tricks. Managing state in Angular isn't really a difficult issue, and yet it becomes exacerbated in other ecosystems due to their delegation of tools to the community and each of the tools not providing good examples/documentation on blessed ways to wire them together, leaving a lot of dev shops with lesser solutions.
At this point, I see the major libraries/frameworks as having a set of more minor tradeoffs for devs to weigh - Angular, React, or whatever will get you where you want to be given the time/resources. With whatever is chosen for the view layer, you will be making time tradeoffs of where you'll spend more time when using Angular, or React, and you will create restrictions as a result. That said, it is perfectly possible to accomplish probably almost everyone's needs with Angular in a timely manner, and probably would be faster to initial market to get a moderately complex app than something like React IMO due to not needing to build certain types of boilerplate/refactoring as much due to lack of foresight about needing a particular system in place in the app.
Note: I have almost 5 years of experience with Angular, and currently have almost a half year of experience leading a very complex React project.
I like React because it's easier to set up and get working; you don't need some ridiculous dev environment just to say "Hello world". I think React does one thing and does it really well, and its flexibility makes it easier to mix and match packages to do what you need to do.
Angular is ridiculously opinionated, and very complete. But for big projects or for multiple projects with different people coming in and out of the project this can be a strong asset. We've had some big React projects where you have to go out and get Redux, then start thinking about observables, maybe you want TypeScript but maybe you want Flow, etc. Angular already thought about all of that, made decisions for you, and structured it in a standard way so that once you learn the conventions it's pretty easy to reason about any Angular project.
And as a front-end dev who got started on the Web in the Netscape days, I appreciate that Angular doesn't treat CSS as a bug to be fixed. React (and the kinds of people who work on React) seem to desire a pure JavaScript world, while Angular keeps a more familiar HTML/CSS convention on the template level.
Quite happy so far.
That being said, it's still a big improvement over everything else I've used that isn't React or Vue.
Angular 1.x interop seems like the only compelling thing about it in my opinion.
There are certainly some issues with Angular. For example, starting Webpack Dev Server is really slow (a minute or longer). Running a lot of tests with Kharma can be slow. If you know what the issues are and can either live with or work around them, then it is not that bad.
React and Vue are reasonable options, but as someone using Angular in production I'd urge you to stay far away from Angular and TypeScript.
I may not choose Angular for every project, but I would certainly never again use untyped JavaScript over TypeScript, for an app of any size, unless there was some unusual and very compelling reason.
(And it would have to be a really unusual reason; I can't even think of a hypothetical one.)
In my own experience, TypeScript is a huge advance over JavaScript without types, in both productivity (how quickly functionality gets implemented) and reliability (how many bugs ever make it all the way to a customer).
I will spice up that factual statement with a bit of speculation that will perhaps be more controversial: in my experience watching other developers move to TypeScript, I think the productivity and reliability gains generally apply to their work too, whether or not they personally like TypeScript.
Say what you will about Angular, but why the hate on TypeScript? I've found using TypeScript one of the better experiences I've had in the Angular ecosystem.
I was initially very curious about Angular2, but our relationship ended very quickly with the discovery of modules and dependency injection. It feels like some kind of arcane over-engineering compared to React's (and vue's) simple and sufficient import-and-use model.
https://github.com/webpack/webpack/issues/5992#issuecomment-...
But all npm package.json dependencies are still anchored on the same ^5.0.0 dependencies that ng v1.5.0 had and still depends on typescript "~2.4.2", basically ignoring the 5.1 announcement.
How can we create a new Angular 5.1 App using ng? Are we meant to manually change all dependencies to ^5.1.0
I also don't get the point of upgrading to the latest angular-cli v1.6 and using it to create the same 5.0.0 app that v1.5 did.
Is the way to create a v5.1 ng app is for everyone to manually update all dependencies to ^5.1.0?
Not changing either.
The app is still in production but parts of it have been rewritten in React since. Despite the added weight of another library, introducing React ironically helped reduce the file size (mostly because it allowed us to remove dependencies that were no longer necessary and the build process changed with bower being replaced by yarn).
EDIT: Another factor in the decision not to upgrade to 1.x when we were able to drop IE8 support as a requirement was that the removal of IE8 support came so abruptly that we decided not to trust Angular to support any browsers that aren't on the latest version (i.e. we expected them to drop IE9 support equally sudden and it seemed clear that Angular 2.0 wasn't going to be built with compatibility in mind).
For comparison, when we added React to the project two years later (when IE8 was no longer a requirement), React still supported IE8 and only several months later announced that they would drop support with the next release. But even then "dropping support" meant that bugs were deprioritised whereas the AngularJS announcement heavily suggested that existing code for IE8 would be intentionally removed or rewritten in a way that breaks compatibility outright and the code should be expected not to work in IE8 at all.
So based on how the announcements were made and what "dropping support" entailed in each library, React seemed the safer bet.
This is common for end-user apps but feels very weird for developer libraries and frameworks.
We are used to X.Y.Z releases where X are "major rewrite", Y are significant updates, and Z are bugfixes.
That said, Angular's new scheme could be technically correct strict "semantic versioning". In semver X.Y.Z, Z releases are supposed to be bugfixes with no feature additions, Y releases add features but with perfect backwards compatibility, and X releases introduce breaking changes. A backwards incompatible change, no matter how small and easy to adjust for, should be a major version bump according to semver.
I work in a large corporation and they're still planning their transition to 1.5 and then to 2. I'm keeping up by building stuff in my off time, but trying to keep a fortune 200 corporation on a six month upgrade track? Not happening.
I've already heard rumblings from upper management of going back to some open source Java frameworks like Spring MVC, Vaadin or gulp Struts because of how fast they are releasing major versions and the time and cost of keeping up.
My fear is Angular will be regulated to startups, medium sized businesses or small autonomous business units within larger companies. When faced with a six month upgrade schedule, many larger organizations I fear are going to balk and just drop it in favor of something they are already comfortable with. . ergo my company wanting to go back to Java since 95% of everything built here is done with Java.
Joking aside, apart from semver another reason for the weird versioning in Angular is that it's a rather large collection of modules, especially if you include things like RxJS (which technically aren't exclusively part of Angular but affect APIs due to their widespread use). So it's fairly easy to get a semver major version bump because of an implementation detail you likely wouldn't care about but that breaks backwards compatibility with some older library in some way.
