This is a large part of the reason behind Ember's philosophy of finding and implementing strategies for stability without stagnation. On the one hand, people (including us) are tired of the constant barrage of new tools and techniques. On the other hand, it would be terrible to get beaten by a competitor that discovered a wonderfully productive new solution. The Ember team has spent the last few years honing a process for dealing with these conflicting desires.
That process involves:
* six-week release cycles, so every new change is incremental and adds value on its own
* canary, beta, and release channels (just like browsers), so that people will more appetite for churn can help test out features, and get them stable by the time they ship as part of a final release
* SemVer, so upgrading across final releases is relatively painless and the biggest part of our community can take advantage of the improvements as they roll out
* having each member of the core team build apps that we care about and maintain, so that we can feel the competing costs of maintenance and keeping pace with the latest and greatest first hand
The core ideas come from shipping browsers, which have had to deal with requirements of very strong stability with an increasing desire to "go fast". The pace of new browser features has been so good, in fact, that they have been used as an argument in favor of completely breaking things and starting over.
Ironically, the browser instead shows us that if we want to avoid stagnation, we are going to have to have strategies for bringing people along. Stability without stagnation is not a paradox; it's a recipe for success.
(we talked a lot more about the nitty-gritty technical details in the previously discussed Ember 2.0 RFC: https://github.com/emberjs/rfcs/pull/15)
This should be an obvious and automatic hype-temperer, but for some reason it isn't.
My opinion is that some types of features are better off bundled in a ready-to-go package. For example data binding and ajax almost always go together and just plopping a CDN link to Angular is a lot easier than installing NPM, setting up a file watcher and who knows what else to get React's JSX running (and you still need to go decide what you're going to use for AJAX).
Other less "core" types of features are better off as standalone libraries because their depth of usage can vary from not being used at all to requiring very domain-specific features (e.g. accounting.js is a good example of this). I don't agree with the author's premise that micro-libraries are easier to swap. I'd be very doubtful if anyone were to claim that it's trivial to convert a React codebase to Knockout, for example. You'd likely be hard-pressed to swap even things like moment.js because you probably chose the library based on it being better than its alternatives to begin with.
But having these types of features be standalone libraries does provide some benefits, e.g. being able to opt-out of a breaking release in a more granular fashion, trial-and-error-oriented development, etc.
That's not the tone we go for on HN.
Additionally, in this case wycat's points are highly relevant to the topic at hand; the article is about churn, and wycat talks about how he addresses that problem in the context of a JS framework.
And, we being somewhat to relatively smart people, can forgive the unmasked market-speak to appreciate the value of the personal experience wycats is sharing.
- React: http://facebook.github.io/react/
- Flux: http://facebook.github.io/flux/
- Jest: http://facebook.github.io/jest/
- Immutable-js: http://facebook.github.io/immutable-js/
- Flow: http://flowtype.org/
- JSX: http://facebook.github.io/jsx/
It is similar to Mithril, but with a strong focus on modularity. To quote the website: "mercury is a small glue layer that composes a set of modules that solves a subset of the frontend problem."
You can basically swap out things that you don't like, use it with Backbone or JSX etc. Its weak point currently is documentation, which is of course a biggie.
The Angular 2 issue is somewhat curious. My biggest question isn't about the new teaser specification. It's what happens to the current version. It's open source, right? I suspect a number of corporate babysitters will provide the support required to make sure 1.x lasts for a decade or more. If you choose to adopt 2.0 for _new_ projects, so be it. Although why on earth the A2 architects chose to break XHTML standards baffles me. An attribute in parens? Seriously?
I personally see the new JS world as a step forward. It's absolutely a molten spew of new and unproven code, but it's also easier to build things than ever before. There are a ton of problems solved with a front-end MVC connecting to a service layer. A TON.
The hard part is that we need better tools all around for JS that we've been spoiled with in C#, C++, Java, and even Assembler.
But one more thing that's hinted at, but I'm suddenly asking myself. What if Anders Hejlsberg (C#/TypeScript) were to publish a monolithic front-end MVC/MVVM framework and its use was built into Visual Studio 2015, which is going to be free at the Pro level? That would throw even more F bombs into the JS world.
In any case, if you're a senior developer or architect and making decisions about technology, you better know what you're doing. You can pick 2% usage code, but you better own it.
Personally, I do C# development in a Windows VM, everything else in OSX. With the new vNext stuff, the only thing still binding me to Windows for anything is the lack of Visual Studio (and WPF). I wouldn't be surprised to see an effort made to bring it to a larger audience now that .NET is going cross-platform.
Outside US, it is a very small number.
In the other southern countries, I seldom know anyone with budget for Macs, unless they happen to work for some cool startup.
I do enterprise consulting across Europe and usually the guys with management positions are the ones with glowing Apples.
Furthermore the computer is a cost so it lowers the taxable income. According to our fiscal laws if you lease something (somebody does that with computers) then it is completely a cost. If you buy it, you can deduce only 20% per year over 5 years. This doesn't apply to goods sold for less than € 500.
Small companies are starting to buy Macs as well. Probably the boss can't have the face to keep a Mac for him/herself and give Windows boxes to the developers :-)
Large companies tend to stick to Windows PCs but they are becoming less inflexible. Again, people used to iPhones started to think that they could work with Macs as well and so it's starting from the top there too.
I think it's less about salary (except to some degree of course) and more about culture. When I do consulting for corporations I also only see Microsoft and HP or IBM, whereas even somewhat struggling freelance graphics designers or developers will have macs.
It was so bad, that last couple of years were spent trying to reproduce it's basic features? I would bet most of web games released today are still Flash. When you leave people with a single choice (this practice is called "open web") then of course it is going to be a "solution".
"...you better know what you're doing..."
Easy solution: move page generation to server, like Twitter did.
The new syntax, while odd looking, is actually completely valid HTML.
Not that I think that's all that important if you're not using XSLT, but just the same, your comment is talking past it a bit.
Npm is stable, Backbone is stable, Node is stable, Gulp is great, and devs like myself who have seen trendy frameworks come and go (Batman.js and jQuery templating come to mind) are still using the same great composable tools that were better designed from the start.
Backbone (and my favorite, Spine) are built on more loosely coupled components and can be used on applications which have no DOM, such as Canvas games or native mobile apps. Browser fragmentation has been an issue since the dawn of JS -- and these days the JS ecosystem extends far beyond the browser.
Take a look at the mature tools for front or backend that major companies rely on and be glad that the open-source nature of JS produces so many options and rapid evolution.
* backed by Google
* plenty of media/blog coverage
* seductive examples (that don't reflect best practices)
My personal gripe is with the last point. A lot of the appeal is in the two-way binding -- which is often the first thing to go out of the window once scaling becomes a problem.
Also, I have no idea why the author thinks Browserify and Angular go well together. They don't. At all. Browserify is great on its own, but there's not really any "blessed" way of using a module system with Angular (and like jQuery Angular 1.x is tightly coupled with the global scope).
It's still the number one selling point and greatly reduces development time in both small and large applications.
The only thing I've seen is that in bigger projects, if there are locations where huge amounts of binding might take place (such as drawing, tables, etc...) you don't use two-way-binding in that particular place.
And in any case many of the popular frameworks (Ember, backbone etc... ) also use two-way binding, they just don't support two-way binding on simple js objects.
And for that many of the bigger frameworks (
Sounds like two-way data binding went out the window then...
When it works - works fine. When it does not work you are completely helpless.
If you have simple modular tools that do something well, and you can string them together in a productive way, it's easier to replace certain pieces.
Maybe in the sense that the APIs will have to change as browsers evolve. But isn't there also some benefit from staying tightly coupled with the DOM? I know that React claims the fact that they are loosely coupled with the DOM is a benefit, but I'm not sure I really understand how this is inherently an advantage.
Web development has always had this pace, whatever tool or setup you commit too, the next week someone will call you an idiot for using it. Ignore them, make something maintainable, nothing in the new framework is ever mission critical, just nice to have.
The site still works great... the codebase is fine. It was before some later changes to bootstrap 3, so it isn't current with the released version, but it still works, and did better so than v2. The same goes for most things involving open-source tools. You can go through migration cycles, or accept and limit the scope of how you use it.
I always applied the same arguments for using Mono in places as a practical reasoning. So what if new development stopped/dropped or rolled.. as long as what I'm doing can keep running.
Your best bet is to keep your codebase modular so much as possible, and it makes it easier to replace certain pieces.
Today, I really like react + yahoo's flux implementation. There are some weird corner cases I've had to deal with, it's still nice. It really just depends on your needs.
I make a habit out of using smaller frameworks that gets the job done, and only that. Anything else or beyond, we code ourselves, or re-use from a different project. Or we just stick with older technology because we know it works. Sure, our productivity might initially be lower, but at least we save ourselves the pain of "the next big thi—oh wait, something new arrived let's switch".
Back when I was starting, it was all about "JS libraries"; when Prototype.js gained the most traction at one point, beating in popularity older Dojo. Still, there were new libs popping up again and again — Mootools, MochiKit, YUI, jQuery. jQuery "won" by introducing a simple and powerful concept of operating on collections via an intuitive API.
Then there were modules — AMD, Require.js, Common.js, etc. New "standards" and libraries competed and everyone claimed to be the best.
In the end, every wave brings something good. Right now we have React & Ractive bringing concept of virtual DOM. It seems long overdue and sorely needed.
Staying at the edge must be exhausting. Staying in the middle of a bell curve is best bang for your buck.
This is the problem with front-end dev in a nutshell. Everybody is mixing and matching their own solutions which makes it impossible for an ecosystem of higher level, reusable components to emerge. Compare this to iOS, for instance, where I can go pick and choose from a huge online library of prebuilt components and be fairly confident I can just "pod install" them and go. I'm not a fan of Angular but it was a good thing for there to be something like a de-facto SPA framework standard. I can only imagine how upset business owners that invested heavily in Angular 1 apps are feeling now.
If web developers are serious about mounting a challenge to the rising tide of native apps, they need to build some consensus and agree on some durable foundations. In the end elegance and novelty count for nothing if you don't have a healthy, stable ecosystem upon which businesses can depend. It's sad to think that the freedom that makes web dev so appealing may also turn out to be its fatal weakness.
If you want to evaluate anew and put together dozens (or hundreds) of tiny modules on every new project, and maintain/evolve that collection over time, fine. But we don't need to tell people that something is deeply wrong if they want a full front-end stack that evolves as the web changes. Nothing is wrong with solutions that track best practices and evolve to incorporate more common problems.
I believe this is the one of the main motivators behind web components
We have a lot more external contributor interested that in the past now, have accepted many more patches, and we just landed Java8 lambda method support, with even more cool stuff to be shown at GWTcreate.com conference in January.
In other words, Google has not removed support from the project, which has continuously existed since 2006. Not sure how much more dedication you want in funding for an open source tool/library.
sorry, Google lost any credibility in this area over the Reader fiasco - Google has no interest in maintaining a project for the good of a community, if it doesn't align with corporate strategy. 8 years history means nothing.
Unless you've paid for a guaranteed period of support, bug fixes and extensions of functionality, this how you should treat all code libraries surely? All libs come as is, and statements of future actions are always expressions of intent, not facts. If your company is utterly dependent on a single free 3rd party library then you should be prepared to take over ownership of it - or accept that your company's survival is at the whim of another. Personally, I would not be swayed by any brand name here - but who would you trust (enough to bet your company on) to provide long term support for a free OSS library?
Personally, I would consider the closing down of a very niche, free, consumer product based on a seemingly dying web technology as a very poor guide towards how Google will treat GWT, which is actually used by them for website development.
When I used to work in Java a few years back, there was a new "favorite" framework every few months:
* build: ant, then maven and just when maven started getting massive traction, gradle.
* web frameworks: JSP, JSF, Spring MVC, Wicket, Tapestry, GWT, struts, dropwizard (and compiled java - Grails, Play etc...).
Even "standards" made by the "governing body" conflicted with each other - JDO, JPO and ESB (the persistence part, though I'm not sure if there was a JSR for that) for example.
A new web shop even had a hard time choosing the Language of the month: Groovy, Scala, Clojure.
If you go broader then the Java world, then the flavour of the week platform was even harder to pinpoint- ASP.net ,PHP,wordpress,drupal,rails, node etc...
Not to mention databases - from everything must be relational in one Monolith DBS (oracle mostly) to sharded mysql with memcache layer, to only noSQL (usually mongodb),then to polyglot persistence (I.E. use what fits) and now into the brave world of natively distributed sql (I.E. newSql).
I don't think it's the front-end that is high churn, I think web development as a whole has changed so much in the last few years that the technologies involved has changed drastically.
At least in front-end development you one language, and the knowledge of some universal standards (you aren't going to need to relearn HTML and css).
Also there is still jQuery- which regardless of how many things are built against it, it exists in practically every site.
I'm not sure that I would call 3 big build systems over the course of 20 years "churn" :-)
> web frameworks: JSP, JSF, Spring MVC, Wicket, Tapestry, GWT, struts, dropwizard (and compiled java - Grails, Play etc...)
The height of the churn corresponded to people trying to handle MVC on the server side, and seems to have subsided somewhat as people have simplified the server side (RESTful APIs) and moved the MVC to the client side.
I wonder if this churn is somehow intrinsic to the type of problem being solved (user interaction), rather than to the technology / language / community.
Maven didn't became really adopted until 2.0 came out, and, to me at least, Gradle gained traction extremely fast after Maven was adopted (along with sbt for scala and others). I think Maven laid out the foundation for the adoption of gradle.
But yes, it's a lot farther apart then Grunt vs Gulp. I was more trying to show that build systems change even for very stable languages/ecoSystems (relatively speaking).
In regards to problem solved - it's an interesting thought, I haven't done a lot of ui outside of web, I wonder if other people can shed some light on churn regarding ui frameworks on desktop (or even flash/silverlight/unity etc...)
Each language had a different purpose:
* Groovy provided a Ruby-like MOP for use with Grails
* Scala provided lazy-eval functional programming and a higher-order type system
* Clojure provided concurrency constructs and Lisp macros
No, all languages had the same purpose: being the best general-purpose programming language. What differed was their approach.
* to buttress one particular piece of software (i.e. Grails) so its project manager can spin a buck selling consulting and conference seats, flipping companies (twice), and take over control of bundled software (i.e. Spring if he hasn't already)
* to keep another project manager in employment by using the Groovy brand to promote himself, diluting control from the technical lead by employing another more compliant programmer, duplicating the functionality of 3rd party addons like Groovy++, setting up a personal website and subscription list to take product control away from Codehaus, etc
Only to the extent Groovy satisfies these purposes does it try to be the best language.
- There are always multiple choices for each piece of functionality you need to address, and personality clashes over which is the "best".
- Security is a whole lot harder to nail down with more moving parts. Go with Angular, you have this: https://code.google.com/p/mustache-security/wiki/AngularJS. Similarly, Ember: https://code.google.com/p/mustache-security/wiki/EmberJS. Even though these frameworks aren't 100% secure (although Angular comes pretty close), you can be more aware of the pitfalls. The more independent modules you have to keep track of in your app, the more difficult it becomes to track security flaws.
- Some seemingly unrelated components just don't end up playing nice with each other, and this can be hard to determine ahead of time.
Web components are the most promising development, because the preferred approach in sw development has always been isolation/separation of concerns. This is pretty much the opposite of the JQuery style. In theory you can separate using JQuery but in practice still in 2014 you cannot look at source in any moderately complex web app and understand what's going on. Ultimately, its going to have to be a DOM/JS mix (Those aren't going away for a long time) but they never got it quite right. The web component frameworks are the best thing going for the future.
IMO they should be declarative, that is - in the HTML - but programmable, and that's the way things have been heading. So in 10 years we'll still have the DOM and JS (although it would be interesting to have more languages easily usable in the browser). As Polymer evolves it (or some equivalent) will make it into the browser.
Sounds like React. WCs templates aren't programmable that's a DSL that is specific to Polymer.
I've been wondering if all this change means that the real way for me to start is diving straight into vanilla JS. I have a firm grasp of Fortran, C++ and experience with MATLAB, SciPy, and Julia (recent) for scientific computing. Coming from the engineering world though, I have no sense how the front-end dev community is shaping up, and that makes me nervous about deciding where to spend my time learning. There are some fun projects I have in mind to bring some of the engineering stuff I've done to the web (e.g. an asteroid redirect mission calculator), but I'm worried about spending time learning a framework that'll just disappear by the time I even really get going.
Does all of this change mean that, in the long-run, I'm best working my way through vanilla JS and at a later stage making using of frameworks or libraries to make the more mundane programming tasks a synch? Or should I actually be starting off by learning a framework? Input highly appreciated!
Yes. If you learn JS really well, you can adapt to the framework-du-jour quickly. Learn the DOM , Learn the Web Standards: Two years from now, these frameworks may or may not matter but the things that are happening in Web Standards like ServiceWorker, Components, RTC, etc. definitely will. If you are searching for the branch to cling to in the storm, it is this: Web Standards (which includes "Vanilla" JS). Start here and work your way outwards: http://youmightnotneedjquery.com/
My interpretation from my limited exposure is that RoR is a big step up from "vanilla Ruby" and that the community in that case is consolidated enough that it's pretty much a no-brainer to just start with RoR as a beginner. In the case of JS it seems like a movement towards consolidation in that sense is still a long way off, meaning that "vanilla JS" knowledge carries more value than it might do 5 years from now. I've also wondered if all the energy that's being pumped into frameworks and libraries wouldn't yield more if it was targeted towards completely replacing JS with something that's more akin to modern (front-end) dev from the ground up. Maybe that's a silly thought, given legacy and the close relationship with browser development, but as an outsider it seems like a lot of energy is spent on "warring" that could perhaps be focussed more productively in a different direction altogether.
Any other JS resources you would recommend to start from the bottom outwards/upwards?
If you are doing webdev, Chrome DevTools is everything. The console and CLI are your window to the truth. It literally spells the difference between wondering why things work like an idiot and knowing it like a boss. Pay special attention to getEventListeners(IClickThisAndItBreaks), debug(WeirdFunction), console.trace().
The things in that list: You should know a lot of them. You should know OF almost all of them (what they do on a conceptual level).
5. Embrace Function-ness: lodash.com/docs
6. Embrace Event-ness: http://api.jquery.com/callbacks.add/
7. Embrace Async-ness. Easiest way for me on this was to dabble with Node - async.js & promises.
8. After you lock all that down (don't get scared - it's actually easier than it sounds), learn how a browser really works and performs. Good place to start on that: http://superherojs.com/ - "Under the Hood" section. (Other good links there, too.)
9. Follow people like Jake Archibald to learn about the Web's "coming soon" stuff like https://jakearchibald.github.io/isserviceworkerready/
1. No modules or dependency management. I believe these are coming in ECMAScript 6, but the browser support isn't there yet. You can invent your own module system by hand and then write out all the script tags but it gets really annoying once you get to say 10 files. I'm using npm (the NodeJS package manager) with Browserify and that seems ok, although there are a few other solutions out there too.
2. I use Lodash to give me some extra operations on functions and collections that aren't in by standard, but I find useful. I'd actually prefer to have a library which provided some good standard data structures instead, but I haven't found the right one yet.
3. DOM manipulation. The standard DOM interface is a bit scabby. I'd recommend D3.js as a pretty nice DOM manipulation library that you can dip into or out of as you like. It's a fairly large learning effort, but I'd say worth it.
Only once you know how these frameworks operate will you be able to make an informed decision as to whether you need something as complex as Angular or React under the hood.
On a more general pov, the debate between "integrated design" and "modularized" design has been going on for decades. We know the advantage of both. The problem right now is that angular made a desition to break compatibility in a major way while their framework was barely becoming mainstream. Let's not make it a bigger problem.
People that invested in the .net framework, or in the unity framework, did not make a blunder. All we need is an equivalent in the front end js world.
Sure, if legacy browser support is not a concern and you don't need to support bleeding-edge features (i.e. unstable APIs), you can go a long way with vanilla JS. But at some point any large system needs abstractions in order to stay maintainable. And if you don't use existing abstractions, you'll have to come up with your own abstractions.
Of course the other option is to simply not build large enough systems to require abstractions.
That said, I do prefer smaller libraries, too. This is why I see React not being a full replacement for all of Angular as a feature rather than a limitation.
I only ever began considering Express as a framework when it dropped the vast majority of its features (mostly middleware) in 4.x, too.
"Any sufficiently complicated collection of libraries contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of a full framework"?
I recently made a simple app and decided to just write it in jquery and constantly found myself missing doing things "The Ember Way"™ Building an "ambitious" application in jquery alone would be complete madness and half-hearted frameworks don't really give you much benefit for all the wrestling you have to do.
I really like that the Ember team strives to find the right way and deprecates parts of the api that they find people using in bad ways. I've also seen a lot a pragmatism around preventing bloat like removing string inflections etc...
The best advice I have if you really want to try Ember is to read the guides, completely, word for word. Then try to write a simple app, using the guides/recipes/API for reference and then read the guides again, completely. Then do all that again. It won't take as long as you think and you'll be far ahead of where you would be reading some introductory blog posts.
Admittedly, I have been frustrated at points, but that's par for the course with any js framework at the moment and if I had chosen Angular 1.x for any of my previous clients, I would be VERY embarrassed right now.
That's a serious advantage for angular - it's pretty small for what you get out of the box, and there are no external dependencies.
I saw in the Ember 2 RFC that they hope to slim down a little, which would be good (especially now that Angular is going mad), but for those of us who don't want to send a great hulking wodge of stuff to every P.O.S. phone that so much as glances at our apps, it's going to have to get a lot smaller.
I write node on backend and frontend, and package the frontend using browserify into a single index.html file that contains everything the app needs, so it's one HTTP request to fetch the app. That's the new binary format of the web, and all the dependency management is done for you. It's bliss. For the frontend I used vanilla JS to write a small Backbone-style library to meet my needs: https://github.com/techlayer/espresso.js because even Backbone seemed too monolithic to me (requires jQuery/Zepto).
I've tried React and Angular, but I simply don't understand what they offer over Vanilla JS. What developers really need is to agree on a package standard (NPM!) so that small libs can flourish. There are tonnes of great libs on github but unless they are in npm, it's just a hassle, let's face it. Frontend devs need to adopt the same approach of publishing everything to npm as Node devs have been doing for years. You don't see monolithic frameworks in Node world because the package management system just works. I don't care about standards, but if everyone embraced something the world would be a much happier place.
My partner and I had about 8 months of dev time into a directory app we were building on the MEAN stack. It just so happens AngularJS was a big part of that architecture.
After some long conversations over beers and some teeth gnashing, one thing became clear. If the Angular team just decided to make these huge changes now, what keeps them from doing it again in the near future? If they have no plans now of making newer versions backwards compatible, does this means every new version will be this way? All it did was create huge questions of trust and reliability with using a framework which could dead end your project somewhere in the distant future. This meant continually looking over your shoulder, which is not good for any business.
Our final decision was to scrap what we were doing with Angular and now are looking at several options which include:
1 - going with a traditional .Net stack / MVC
2 - going with Django or other Python framework
3 - moving to another JS framework like Ember
Either way, We're moving away from Angular. Call me gun shy, call me spooked by the latest change in direction, but I have a bad feeling about how this is going to turn out in the next 18-24 months.
His biggest example, the Angular 2.0 split, is of the second one, but he seems primarily concerned with the first one.
I can see the first one being a problem primarily for developers keeping their skills up to date. The fact is that once you've put a decent amount of code down into an application, you're not going to be constantly switching frameworks. Maybe do it once, but otherwise the applications that are already built will stay on a stable foundation. So for developers working on a single or stable set of applications (not client work), this shouldn't effect their actual work. There may be an issue of skill decay if employers are constantly looking for the latest and greatest, but outside the Silicon valley bubble, I still see a lot more jQuery and Backbone job postings than Ember or React.
As for the issue of frameworks lacking stability, I frankly don't see that. Yes Angular is making big breaking changes. But otherwise? Let's look at the other 6 biggest front end libraries/frameworks.
jQuery has been fairly stable for a few years now, with minimal breaking changes.
Underscore has been very stable, albeit growing with competition/help from Lo-Dash
Knockout and Backbone have evolved slowly while remaining small and very small respectively.
Ember has a very clear process for moving their framework while allowing actively developed applications to stay up to date in a reasonable way.
React is still pre 1.0 and that's something you should know going in.
Basically if you started a project with any of those technologies (or angular for that matter) at some point in the past 3 years, you've probably had a pretty easy time in adjusting as the library specific concepts have changed.
I just don't see the idea of "Frameworks are evolving too quickly" as being particularly compelling. There's a lot of information out there. Yes if you want to know it all and always be using the newest shiny thing, it will probably be too much. But none of this is preventing anyone from actually building useful things today.
You keep using the term "Google" as though it represents a single, unified entity aligned on all fronts. Angular was never an official initiative within Google and its usage within Google is actually pretty limited. It's a Google framework in name only. It grew organically out of one small team's (who happened to work at Google) desire to simplify the rewrite of a very large legacy web app (DoubleClick). It's no more "Google Angular" than Bootstrap is "Twitter Bootstrap", which was another project that started within large, recognizable company but wasn't officially initiated or mandated by said company. I'm sure Google employees are sick of people lumping them into one big group and making blanket statements such as the ones you made in your comment.
> I don't see anything else that it meaningfully shares with Angular 1
Then you haven't been paying attention. Angular 2.0 still has dependency injection, directives, two-way binding, scopes, routing, and more. Directives are being renamed to match more common terminology and scopes are now just implied but these are improvements, not removals.
> I think it'd be foolish to choose Angular 1 or 2 at this point, knowing that there will be literally no support from the creators.
This is just FUD. The creators have said they will continue supporting Angular 1.0 well after Angular 2.0 is released; they even hired a few people recently to do just that. And there are core contributors out there who don't work for Google who will likely keep supporting Angular 1.0 for as long as it makes sense to. It's open source, after all. And to say that Angular 2.0 will receive "literally no support from the creators" is simply trolling.
Reading your post reminded me of Robert C. Martin (Uncle Bob) opinions on how coupling your code with anything that can screw you over obviously is a bad idea.
"Apparently the notion that it’s a good idea to hide the framework, UI, or database from the application code is not universally accepted."
"What happened to us? How did we forget these rules? When did the old rules of coupling and cohesion evaporate from our awareness? Are we really so naive as to think that the best way to write a complex system is to throw a bunch of components into a bag and shake it until it works?"
As an aside, I think it's notable what a barrier to entry all this is. If you want to try your hand at web app development the thicket of libraries is not a welcoming prospect...
I got burned a long time ago when I wrote a large personal project using ExtJS (~1.2 i think). Breaking changes, coupled with a kitchen sink mentality soured me against large frameworks.
It's vanilla JS with a few small very targeted libraries to fill in the gaps from now on for me.
1. Change of behaviour between versions, (e.g. the way a frameworks integrate with a page)
2. Reliance on functionality being supported into the future
3. Customer expectations
4. Browser support
That said, it is true that a frameworks gives you the ability to put together an app in a few weeks. However, when you know that what deal with with something that needs to be maintained for years than knowing what does each piece of your code is far more important.
As a good example, we're on the verge of ditching JQuery.
I always have to dive into the guts of a library to figure out bugs regardless - I feel like that's essential for a software engineer to become well versed in, regardless of whether the work is in frontend or backend.
The cost of not producing at a fast enough rate is something almost no business can afford, especially in the startup world. The speed at which companies have to move are always on full thrust because if they don't move fast enough, then it costs sales, reputation, and gives competitors more of an opportunity for market entry.
Homerolling your own framework/library can be a dangerous operation, and you lose the benefits of the lessons that others have learned in maintaining open source frameworks/libraries.
Yes. Only the code you wish wouldn't!
(seriously. I'm maintaining complex logic in ant. AUGH MY EYES)
I fail to see how improvements in these tools actually push us to create novel projects. While one can nit-pick about React.js rendering performance in its internal "DOM diff" model or Flux's "data flow architecture" in improving code readability, but they are just buzzwords to me like words-play in a post-modern novel or art that arrange concepts in their idiosyncratic way in an arbitrary aesthetic way; although sometimes the rearrangements can be beautiful, they are ultimately shrines to themselves and their creators and subculture.
Subculture because everyone wants something of their own and ignore interoperability. Although the data model are the same whether you're a single-page or isomorphic, there is no community standard to define standards to define your data models a la J2EE annotations or code-generated one's a la Google Protobuf. Same thing with single app controllers, no standard like RESTful web service spec that's universal and interoperable like between .net/Java/Python etc. that can be applied to say, Sail/Backbone/Ember/Angular.
Postmodern because they are always self-referential to the "Ember.js"/"Node.js" way of doing thing - when they all do the same thing which is rendering HTML elements on the web browser in 2014, much like Visual Basic rendering forms on Windows 95 desktop in 1997. Never mind all the touts about performance, architecture, when the users won't care about the diminishing return of shaving off some microseconds of your AMD JS module loading or the beauty of your invisible architecture.
IMHO, instead of a race to the bottom to the most "efficient" and "beautiful" stack to render HTML, I care more about the ideas that push the web as a medium, e.g.,
Web Audio API (https://chromium.googlecode.com/svn/trunk/samples/audio/samp...),
Web Real Time Collaboration (https://togetherjs.com/ http://www.webrtc.org/)
This is what I'm trying to accomplish with intercooler.js: http://intercoolerjs.org/
I think many devs are both backend & front-end craftsmen, and as so build the backend first and then wish to 'grow' their frontend part on that foundation. Or ideally wish they could. Instead they have to fork the project into 1). the Good Ol' server HTML part 2). the API SPA part.
No matter how close angular or react (with jsx) stays to HTML, you still need to rewrite the whole view to comply with it's templating needs. There's no incremental evolution there, and worse : having to duplicate and sync maintenance on both ends, breaks the DRY principle which is fundamentally bad - since you end up with 2 sources of truth.
Pre-rendering the view with react on node (even if your on rails or whatever) may be a solution I don't know yet. Another take I guess would be to render your server html files with a template which complies with their JS counterpart. Yet another take would be to use HTML as the API instead of JSON - which is proven to work quiet well.
Anyways, just to conclude I think devs would feel more confident if they could rely a little more on the servers end while the frontend finds its ways and stabilizes a little.
You might want to jump in on the thread and we'll see if we can coordinate a syntax you find amenable to your style of programming.
Java/Clojure with Nashorn works easily (you need JDK8 though).
I couldn't get anything working w/ Go other than Otto, a JS interpreter written in Go, which is too slow.
For an even more retro approach, perhaps some things are just better written as desktop apps. I know they're out of vogue at the moment, but I've been having good experiences with writing a JavaFX app lately. Particular points to note:
* I wrote my own online updates engine, that can be used to implement Chrome/Web style silent background updates, but which can also give control to the user over which version of the app they use. Users can downgrade at any time if a new version is buggy or just not as good as the previous version. It's very small, simple and easily integrated. It supports threshold signed updates so it's also suitable for high security apps where a hacked web server could be critical. It's called UpdateFX, check it out.
* JavaFX has a tool that creates native, bundled installers on each platform (dmg, exe/msi and deb). The user does not have to install JVMs or get any Ask Toolbar crap on their system. You remain in total control over JRE upgrades.
* UI is specified with an XML dialect called FXML, it's quite intuitive and anyone who knows HTML can pick it up quickly. But there's also (unlike with the web) a competent visual designer. You can style UI with a dialect of CSS and it's very easy to match the Twitter bootstrap look, native looks can be done too.
* Data binding is easy, the UI is OpenGL/Direct3D hardware accelerated, you can trivially apply effects like drop shadows or blurs and animate them, the API is clean, the entire framework is open source and the developers are responsive.
* Because it's not a web app, support for offline or flaky internet connections is second nature.
If your users can tolerate the initial download then it's a much more pleasant and robust development experience. If your users are the type who can't wait, you might want to stick with the web.
This is effectively what the mobile marketplace has decided. Native mobile apps are thriving while mobile web apps struggle to keep up.
I will say, a well done client/server app is much more difficult to implement robustly than a web app. And, horror of horrors, users usually expect you to implement... undo!
Yes people have higher expectations from native apps, it's true.
Of course it all depends on the domain and architecture of the app in question, so counter-examples and exceptions are easy enough to find.
Of course, people might indeed think that's lame and sucky whereas they'd forgive it for a web app. This is one reason I made my app visually look like a web app e.g. no menu bars and a bootstrap/web style button/popup aesthetic. If it looks like a duck, people are more forgiving if it quacks like one sometimes too :)
Some projects get a bit flashy and buzzwordy, it's true. Bacon.js  always sticks out in my mind as a prototypical example, though I think it's tongue-in-cheek.
I try not to let that flashiness get in the way, though. The fact is, Bacon.js is useful to me, when I try to make beautiful and efficient code to render beautiful and efficient HTML. Their homepage doesn't change that. React's performance is impressive, and may be important to me; ditto with Flux and code readability. And the theories underlying those libraries (DOM diff and unidrectional data flow) are important too, so I know why I should expect them to be better.
But I'd rather be programming iOS any day, so maybe my tastes in client-side application programming are very out-of-step.
For past 4 years, there is NPM, and there is people trying to explain why you should build your software with modules instead of frameworks.
I know, this will probably evoke a "No true Unixman" response, maybe even with pointers towards the Plan 9 highlands, but the truth is that a) connecting stuff is hard and b) a good connection is often a prime feature itself.
Especially the latter will result into a plethora of modules of its own, for nearly all possible combinations of component modules. The end result is even more "frameworks". Sure, they're going to be modular frameworks, but I don't really know whether that's going to help the developers who live in the uncanny valley of mostly knowing what's there and how it connects.
When I spent some time in the node.js world, I felt the same thing: there were a few attempts at frameworks, but most everybody was writing their own glue framework between microlibraries. I am convinced that it is only fun the first few times you have to do it. :) It reminds me a little of the days before server side frameworks, where people were reinventing the wheel (poorly) every project.
Further, I don't think it's necessary to run and learn every single framework that comes out. If something is an order of magnitude better, it will take over the market. (Ember, Angular, and React are all an order of magnitude better than backbone.) There will come something that is an order of magnitude better than these eventually. Until then, just get stuff done.
And frankly, there's no shame in continuing to render on the server until that next generation leap comes.
Thats why so many things changed too.
And the other thing is: why are all those things so successfully? People had enough from old fat frameworks, that where developed 10 years ago with a language from 15 or 20 years ago.
This old languages and frameworks did not fit to Web-Development, Apps, whatever... all the things that boomed since 2007.
Well, that would reduce the framework churn rate for an individual developer to exactly the rate that said developer gets new projects. Too bad about the NEXT dev on the project, tho...
I don't remember ever seeing anything like this level of churn, and I've been programming since the early nineties. Not with Java, not with Python, not with anything.
Someone above mentioned rolling their own stuff with vanilla JS (which provoked an immediate invocation of Greenspun's tenth rule). My sense is that a lot of people start out this way and say, "Lo, a library! Github!"
One hopes that the cream rises to the top, but I'm drowning in milk.
AngularJS scales really well on gigantic applications, and it felt like there was going to be some stability from the corporate-world, but now it's gone.
Frontend code is so hard to maintain well (compared to backend), and now it's going to cost companies millions of dollars to migrate: retraining, migration, unit-testing, QA
Web Components looks hugely promising as the path for independent components - essentially what Angular directives were meant to be in the absence of such browser technology.
Simple libraries often mean less maintenance headaches, more flexibility, and better productivity over the long term. YMMV of course ;-)
Exoskeleton looks like a promising microframework replacement for Backbone.js - http://exosjs.com/
Edit: re: downvotes. I know, sometimes it hurts to hear there are other ways that may be more optimal. Been there. Developing software is hard sometimes but it's a craft :-)
Perhaps it's better now that the api has stabilized a bit. I've been using node.js & some Sinatra lately.
Upgrades tend to be smoother & due to less monolithic libraries. Also, the app startup time & TDD cycle tends to be faster with slimmer libraries.
It's also nice to be close to http vs the ambiguous controller methods & complicated route files.
Plus ActiveRecord is slow, especially with collections. The business logic can often be implemented in simple functions, resulting is less abstraction overhead.
Also, I find business logic sql libs written by typical devs tend to be unreadable and much buggier than AR code. They start clean, but once some other devs make some edits, they end up a jumble of sql concatenation nightmares (even if you use prepared statements, and especially if you've ever switched sql dialects). Given the choice, I think I'd rather see them written as stored procedures. At least that enforces decoupling.
I agree with your other points -- less code is more better.
Find something that works for your team and stick with it. No one is making you use the latest framework or library out there.
I for one am perfectly able to track all this innovation within my specialties (enterprise web dev) across multiple language ecosystems, and if I miss something, someone in my monkeysphere will make me aware of it, all of this fuss sounds like hot air to me.
I say keep calm and watch it churn.
When it stops churning, whatever comes out is going to be worth it
Lucky if you can work with a disciplined team...
Also not sure I can get on board with "lots of quality code in PHP", some sure, but seems that anyone who knows PHP and another language prefers to write in another language.
The are emergent (PSR) standards nicely backed by all the leaders in the community (Symfony, Laravel, Silex, Drupal 8.) The Doctrine ORM is also an extremely pleasant way to interact with a relational DB (on par with Python's SQLAlchemy.) I very deeply hated PHP but nowadays I find it fun to develop and ship software written in PHP.
It's also funny that you listed 4 actors as "all the leaders" when Laravel uses mostly Symfony code, Silex is made by Symfony, and Drupal is known to be terrible.
The last time I had to program something real in PHP, I got caught trying to debug network calls (all PHP debugging is an exercise in futility, you just never know, am I going to throw an error, return 0, return -1/false/something else, is it something that gets swallowed by the interpreter?) and tried to use a try/catch to catch all exceptions. So pretty much "catch (Exception $e)". Except that, since I was trying to be good and use PSR, I was using namespaces, and PHP does not search the root namespace unless you are in the root namespace. Which is ridiculous and the only language I know to do that. The really infuriating part however was that the interpreter gave no indication whatsoever that something was wrong, it just silently failed. Making it ironic that by dint of using an error construct, I was prevented from seeing compile errors in my code.
It's so easy to just, `npm install` or `bower install` a new library, sometimes you don't even think about it. But, this causes a huge bloat and duplicated functionality that both produce huge build artifacts and increase the learning curve.
You need to make sure you have at least one person dedicated to saying, "I know B does X better, but, we are already using A and it does X good enough."
If you stay away from technologies because there are developers out there misusing it, I doubt you'll be left with much but machine code.
Our devs are a very smart and capable bunch, but are slowly learning the Support Hangover of being the knowledgeable one on a project because you made a foolish and enthusiastic choice when the project was launched ... it's how you learn the "-ops" bit of devops.
Some year webdev will grow out of the CADT model, but it won't be this year.
My preferred way of working in a lot of projects is to work with the DOM directly but keep the code that is DOM-aware as minimal as possible, and call my domain layer right from the event handler after extracting the needed info (id, ...) from the event and target.
IMHO, data-binding is not that useful in most projects.
Sigh... with AngularJS 2, I'm shuddering at all the unit tests that will have to be rewritten.
I have not dipped my toes into a production app with ember or angular because of the same list of concerns put forward by folks here and on the other-webs.
The web has always changed quickly because that is the only way it can survive. If you think you can write an app and let it sit there for years you're silly.
Technology: there is no end game.
While there are some Rails-like frameworks for node (e.g. Sails), node simply lends itself to a more service-oriented architecture, with lots of much smaller, much more specialised applications rather than one big monolithic MVC behemoth.
IOW, if you were able to replace your node app with Rails, you probably were trying to build a Rails app in the first place. Otherwise you'd probably have used something more like Sinatra.
Or are you talking about node?
But, don't put tldr; on bottom of the article.
As the article states, there was a time a few years ago that js-all-the-things appeared interesting and unstoppable. To me it appears in 1 year when Win10 arrives, people will have better spent their time honing skills for native apps.
Webapps as people envision them (universal applications) will die- returning to their original intention. Document sharing and simple data collection/retrieval.
Blame Eich and Mozilla for that. They insisted on pushing no bytecode for the web. Wanting us to rely on Eich's JS + rest of the webstack monstrosity requiring ugly hacks.
Don't. They get so much for free that other developers have to work on hard (flexible data binding, easy portability and trivial deployment).
> They insisted on pushing no bytecode for the web. Wanting us to rely on Eich's JS + rest of the webstack monstrosity requiring ugly hacks.
I fully agree here. The whole "JS is not that bad" mindset is firmly ingrained in people's minds, which is a shame.
Win8 IMO is almost irrelevant, the marketshare isn't there to add a MS Store option for me or many others. The corporations haven't and won't hop on. Everyone is (IMO rightly) focused on iOS/Android/web at the moment. Agreed on MSIs, but I'd add the customizable corporate frontend stores should be more powerful and slick than the current method (same appstore for MS desktop and mobile). It's possible once enterprise moves to the MS Store that MS mobile devices make major inroads.
For consumers, I think they'll rejoice at Win10, upgrade to it and by default go to the MS Store for security reasons alone. Not to mention auto-updates, same apps as on MS mobile etc.
I'm not pro-MS, I'm actually anti-all-for-profits and a Mozilla fanboy. I just disagree with Eich on a bytecode for the web, he blew it as far as the web being the prime delivery mechanism for apps is concerned. The webstack sucks, it had to go. Too late now.
I understand my view isn't popular at the moment. Especially among webdevs who are most likely to be reading this HN post. Those people have invested heavily in the webapp dream with their time, skills and careers. Anything to the contrary that it was a great idea is going to get downvoted. Regardless, I think this is an accurate reading of the foreseeable future.
It's not accurate at all though.
My prediction is that your prediction is dead wrong. Nothing will stop the web, certainly not your app store dystopia, and certainly not the way Microsoft would run it.
Presuming about my intentions or feelings towards the MS ecosystem is ridiculous. I had courses on VB6 in the late 90s, that's the closest and most exposure I've ever had to their ecosystem. I do wish I knew C# now that .Net is merging with Mono though. I see no shame in that. I don't hate MS anymore than I do Google, Apple, Oracle or ANY for-profit. For-profit means not-in-my-best-interests.
"Nothing will stop the web" sounds way too much like the idiotic quote, "always bet on JS". I'm not betting on JS with Eich, but I'm not against the web. Certainly my HN post of what I think will happen, won't affect that outcome.
I'm with (I believe) most everyone in supporting webapps being the universal delivery mechanism for apps in the future. Where did I say I wasn't? I also think there was a limited window of opportunity for this to take off. That window roughly being 2004-2014. Today, native apps are still on top.
Webapps will continue on in some form. But with Apple and Google already having appstores, will a popular version of Windows with an appstore be the closing of that door? That door being defined as webapps becoming the dominant application delivery platform. Yes, I think so.
But as of today, I fully believe webapps were/are hobbled during their glory years by the webstack, the web needed a bytecode.
If someone merely looking at circumstances and speaking on them bothers you so much, you are likely someone who speaks only to persuade others to your viewpoint. I'm not trying to persuade you and don't care where you stand. Frankly, I'm more than likely aligned with your views on webapps. I just personally find the webstack inconducive with the goal.
Action needed to be taken at a high level (likely at Mozilla, to make the webstack legacy and introduce a new bytecode standard), in a window of opportunity while the last major player (MS) was essentially out of the appstore business. I don't see it happening in time now. We'll see, but I predict it is you who has an emotional investment in the webstack.
Best I'm aware, a lot of these apps exist already. The step we've yet to reach is "having to launch" instead of merely being able to launch. We probably will for some of them, though.
Very few people use them, however.
The situation isn't that great for native apps either. Most times, you're lucky if an app has targeted more than just one platform. And try running modern native apps on the 1st gen iPad; developers leave old tech in the dust regardless of which platform their targeting.
Simple text files (markup, styles) sent over the network to the client, which interprets them in a predictable way to show your UI and data (the predictable part has improved much over the last decade).
I do agree with you though that not having a bytecode for the web is a severe restriction on front-end development, and means that I prefer doing backend web work and using js in a limited way for ajax etc, not trying to use it to generate entire documents/UIs. Personally I find JS is fine for limited tasks, but not for writing apps in without quite a lot of pain. I expect that to be addressed at some point soon though, either by asm.js (not optimal), or something like Nacl. Till then, it's bliss working in whatever tools I want on the backend, even switching out tools if I want to, without the end user even knowing that I'm using a different stack - to them what is important is the app, not what it is written in - that is as it should be, and not something you see on other platforms. That's the attraction of web development for me, and one that native development will never equal.
Will OS vendors continue to dominate computing? I think that's a more interesting question, and one we'll see play out over the next few decades. The web may yet reduce native platforms to a set of badly debugged device drivers.
Survival of the fittest. Churn is just necessary. The front end world is a huge ecosystem which is constantly evolving.
That said, I can build an app in Angular today, and when something flashier comes out, I can code new features/modules to my app using that.
- fix it yourself
- give up: turn off your app
- ignore: let people deal with the issue/be vulnerable