What is Durandal and what are its top alternatives?
Top Alternatives to Durandal
- Aurelia
Aurelia is a next generation JavaScript client framework that leverages simple conventions to empower your creativity. ...
- React
Lots of people use React as the V in MVC. Since React makes no assumptions about the rest of your technology stack, it's easy to try it out on a small feature in an existing project. ...
- AngularJS
AngularJS lets you write client-side web applications as if you had a smarter browser. It lets you use good old HTML (or HAML, Jade and friends!) as your template language and lets you extend HTML’s syntax to express your application’s components clearly and succinctly. It automatically synchronizes data from your UI (view) with your JavaScript objects (model) through 2-way data binding. ...
- Knockout
It is a JavaScript library that helps you to create rich, responsive display and editor user interfaces with a clean underlying data model. Any time you have sections of UI that update dynamically (e.g., changing depending on the user’s actions or when an external data source changes), it can help you implement it more simply and maintainably. ...
- Vue.js
It is a library for building interactive web interfaces. It provides data-reactive components with a simple and flexible API. ...
- Backbone.js
Backbone supplies structure to JavaScript-heavy applications by providing models key-value binding and custom events, collections with a rich API of enumerable functions, views with declarative event handling, and connects it all to your existing application over a RESTful JSON interface. ...
- Angular
It is a TypeScript-based open-source web application framework. It is a development platform for building mobile and desktop web applications. ...
- Ember.js
A JavaScript framework that does all of the heavy lifting that you'd normally have to do by hand. There are tasks that are common to every web app; It does those things for you, so you can focus on building killer features and UI. ...
Durandal alternatives & related posts
Aurelia
- Simple with conventions47
- Modern architecture42
- Makes sense and is mostly javascript not framework39
- Extensible31
- Integrates well with other components28
- Easy to use27
- Dependency Injection25
- Modular22
- Great router20
- Adaptive Data Binding16
- Typescript, ES2015, ES201613
- IoC, Modularity, Simplicity, Full Stack11
- Good binding system9
- Based on ES79
- Testable6
- Convention based6
- Quick to develop5
- Solid Documentation4
- Evolving standards compliance4
- Smooth learning curve4
- Outstanding Support (paid)4
- Reactive binding system1
- TypeScript1
related Aurelia posts
At Beamery we had a large, AngularJS app, built over several years. Our clients were happy, but we were not. We had several problems: Building new features was slow. AngularJS doesn’t scale nicely. Features clash with each other. Isolation doesn’t come as standard, you have to work hard to keep features separate. It takes time to get it right. #Hiring was hard, for all the reasons listed above. The app was slower than it needed to be because AngularJS was never built for speed. We wanted to render half a million contacts, and Angular was fighting us all the way.
As time went by it become harder to find developers who would willingly choose AngularJS over React Angular 2 , Vue.js , Aurelia or Polymer .
So we faced a choice. We could throw it all away and start again, we could upgrade to Angular 5, or the awesome option - we could use micro frontends. We chose the awesome option.
- Components830
- Virtual dom672
- Performance578
- Simplicity507
- Composable442
- Data flow186
- Declarative166
- Isn't an mvc framework128
- Reactive updates120
- Explicit app state115
- JSX50
- Learn once, write everywhere29
- Easy to Use22
- Uni-directional data flow21
- Works great with Flux Architecture17
- Great perfomance11
- Javascript10
- Built by Facebook9
- TypeScript support8
- Speed6
- Server Side Rendering6
- Feels like the 90s5
- Excellent Documentation5
- Props5
- Functional5
- Easy as Lego5
- Closer to standard JavaScript and HTML than others5
- Cross-platform5
- Easy to start5
- Hooks5
- Awesome5
- Scalable5
- Super easy4
- Allows creating single page applications4
- Server side views4
- Sdfsdfsdf4
- Start simple4
- Strong Community4
- Fancy third party tools4
- Scales super well4
- Has arrow functions3
- Beautiful and Neat Component Management3
- Just the View of MVC3
- Simple, easy to reason about and makes you productive3
- Fast evolving3
- SSR3
- Great migration pathway for older systems3
- Rich ecosystem3
- Simple3
- Has functional components3
- Every decision architecture wise makes sense3
- Very gentle learning curve3
- Split your UI into components with one true state2
- Recharts2
- Permissively-licensed2
- Fragments2
- Sharable2
- Image upload2
- HTML-like2
- React hooks1
- Datatables1
- Requires discipline to keep architecture organized40
- No predefined way to structure your app29
- Need to be familiar with lots of third party packages28
- JSX13
- Not enterprise friendly10
- One-way binding only6
- State consistency with backend neglected3
- Bad Documentation3
- Error boundary is needed2
- Paradigms change too fast2
related React posts
I am starting to become a full-stack developer, by choosing and learning .NET Core for API Development, Angular CLI / React for UI Development, MongoDB for database, as it a NoSQL DB and Flutter / React Native for Mobile App Development. Using Postman, Markdown and Visual Studio Code for development.
I picked up an idea to develop and it was no brainer I had to go with React for the frontend. I was faced with challenges when it came to what component framework to use. I had worked extensively with Material-UI but I needed something different that would offer me wider range of well customized components (I became pretty slow at styling). I brought in Evergreen after several sampling and reads online but again, after several prototype development against Evergreen—since I was using TypeScript and I had to import custom Type, it felt exhaustive. After I validated Evergreen with the designs of the idea I was developing, I also noticed I might have to do a lot of styling. I later stumbled on Material Kit, the one specifically made for React . It was promising with beautifully crafted components, most of which fits into the designs pages I had on ground.
A major problem of Material Kit for me is it isn't written in TypeScript and there isn't any plans to support its TypeScript version. I rolled up my sleeve and started converting their components to TypeScript and if you'll ask me, I am still on it.
In summary, I used the Create React App with TypeScript support and I am spending some time converting Material Kit to TypeScript before I start developing against it. All of these components are going to be hosted on Bit.
If you feel I am crazy or I have gotten something wrong, I'll be willing to listen to your opinion. Also, if you want to have a share of whatever TypeScript version of Material Kit I end up coming up with, let me know.
- Quick to develop889
- Great mvc589
- Powerful573
- Restful520
- Backed by google505
- Two-way data binding349
- Javascript343
- Open source329
- Dependency injection307
- Readable197
- Fast75
- Directives65
- Great community63
- Free57
- Extend html vocabulary38
- Components29
- Easy to test26
- Easy to learn25
- Easy to templates24
- Great documentation23
- Easy to start21
- Awesome19
- Light weight18
- Angular 2.015
- Efficient14
- Javascript mvw framework14
- Great extensions14
- Easy to prototype with11
- High performance9
- Coffeescript9
- Two-way binding8
- Lots of community modules8
- Mvc8
- Easy to e2e7
- Clean and keeps code readable7
- One of the best frameworks6
- Easy for small applications6
- Works great with jquery5
- Fast development5
- I do not touch DOM4
- The two-way Data Binding is awesome4
- Hierarchical Data Structure3
- Be a developer, not a plumber.3
- Declarative programming3
- Typescript3
- Dart3
- Community3
- Fkin awesome2
- Opinionated in the right areas2
- Supports api , easy development2
- Common Place2
- Very very useful and fast framework for development2
- Linear learning curve2
- Great2
- Amazing community support2
- Readable code2
- Programming fun again2
- The powerful of binding, routing and controlling routes2
- Scopes2
- Consistency with backend architecture if using Nest2
- Fk react, all my homies hate react1
- Complex12
- Event Listener Overload3
- Dependency injection3
- Hard to learn2
- Learning Curve2
related AngularJS posts
Our whole Node.js backend stack consists of the following tools:
- Lerna as a tool for multi package and multi repository management
- npm as package manager
- NestJS as Node.js framework
- TypeScript as programming language
- ExpressJS as web server
- Swagger UI for visualizing and interacting with the API’s resources
- Postman as a tool for API development
- TypeORM as object relational mapping layer
- JSON Web Token for access token management
The main reason we have chosen Node.js over PHP is related to the following artifacts:
- Made for the web and widely in use: Node.js is a software platform for developing server-side network services. Well-known projects that rely on Node.js include the blogging software Ghost, the project management tool Trello and the operating system WebOS. Node.js requires the JavaScript runtime environment V8, which was specially developed by Google for the popular Chrome browser. This guarantees a very resource-saving architecture, which qualifies Node.js especially for the operation of a web server. Ryan Dahl, the developer of Node.js, released the first stable version on May 27, 2009. He developed Node.js out of dissatisfaction with the possibilities that JavaScript offered at the time. The basic functionality of Node.js has been mapped with JavaScript since the first version, which can be expanded with a large number of different modules. The current package managers (npm or Yarn) for Node.js know more than 1,000,000 of these modules.
- Fast server-side solutions: Node.js adopts the JavaScript "event-loop" to create non-blocking I/O applications that conveniently serve simultaneous events. With the standard available asynchronous processing within JavaScript/TypeScript, highly scalable, server-side solutions can be realized. The efficient use of the CPU and the RAM is maximized and more simultaneous requests can be processed than with conventional multi-thread servers.
- A language along the entire stack: Widely used frameworks such as React or AngularJS or Vue.js, which we prefer, are written in JavaScript/TypeScript. If Node.js is now used on the server side, you can use all the advantages of a uniform script language throughout the entire application development. The same language in the back- and frontend simplifies the maintenance of the application and also the coordination within the development team.
- Flexibility: Node.js sets very few strict dependencies, rules and guidelines and thus grants a high degree of flexibility in application development. There are no strict conventions so that the appropriate architecture, design structures, modules and features can be freely selected for the development.
Our whole Vue.js frontend stack (incl. SSR) consists of the following tools:
- Nuxt.js consisting of Vue CLI, Vue Router, vuex, Webpack and Sass (Bundler for HTML5, CSS 3), Babel (Transpiler for JavaScript),
- Vue Styleguidist as our style guide and pool of developed Vue.js components
- Vuetify as Material Component Framework (for fast app development)
- TypeScript as programming language
- Apollo / GraphQL (incl. GraphiQL) for data access layer (https://apollo.vuejs.org/)
- ESLint, TSLint and Prettier for coding style and code analyzes
- Jest as testing framework
- Google Fonts and Font Awesome for typography and icon toolkit
- NativeScript-Vue for mobile development
The main reason we have chosen Vue.js over React and AngularJS is related to the following artifacts:
- Empowered HTML. Vue.js has many similar approaches with Angular. This helps to optimize HTML blocks handling with the use of different components.
- Detailed documentation. Vue.js has very good documentation which can fasten learning curve for developers.
- Adaptability. It provides a rapid switching period from other frameworks. It has similarities with Angular and React in terms of design and architecture.
- Awesome integration. Vue.js can be used for both building single-page applications and more difficult web interfaces of apps. Smaller interactive parts can be easily integrated into the existing infrastructure with no negative effect on the entire system.
- Large scaling. Vue.js can help to develop pretty large reusable templates.
- Tiny size. Vue.js weights around 20KB keeping its speed and flexibility. It allows reaching much better performance in comparison to other frameworks.
- Data centered application3
- Great for validations2
- Open source1
related Knockout posts
- Simple and easy to start with293
- Good documentation229
- Components196
- Simple the best131
- Simplified AngularJS100
- Reactive94
- Intuitive APIs77
- Javascript56
- Changed my front end coding life52
- Configuration is smooth48
- Easy to learn37
- So much fun to use35
- Progressive25
- Virtual dom22
- Faster than bulldogs on hot tarmac16
- Component is template, javascript and style in one12
- It's magic12
- Perfomance10
- Light Weight10
- Best of Both Worlds9
- Intuitive and easy to use8
- Elegant design8
- Application structure8
- Without misleading licenses8
- Small learning curve6
- Good command line interface6
- Logicless templates5
- Like Angular only quicker to get started with5
- Single file components5
- Easy to integrate to HTML by inline-templates5
- High performance4
- Vuex3
- Component based3
- Customer Render ending eg to HTML3
- Bridge from Web Development to JS Development3
- Concise error messages2
- Supports several template languages2
- One-way data flow2
- Lots of documentation2
- Intuitive2
- GUI1
- Less Common Place9
- YXMLvsHTML Markup5
- Don't support fragments3
- Only support programatically multiple root nodes3
related Vue.js posts
Our whole Node.js backend stack consists of the following tools:
- Lerna as a tool for multi package and multi repository management
- npm as package manager
- NestJS as Node.js framework
- TypeScript as programming language
- ExpressJS as web server
- Swagger UI for visualizing and interacting with the API’s resources
- Postman as a tool for API development
- TypeORM as object relational mapping layer
- JSON Web Token for access token management
The main reason we have chosen Node.js over PHP is related to the following artifacts:
- Made for the web and widely in use: Node.js is a software platform for developing server-side network services. Well-known projects that rely on Node.js include the blogging software Ghost, the project management tool Trello and the operating system WebOS. Node.js requires the JavaScript runtime environment V8, which was specially developed by Google for the popular Chrome browser. This guarantees a very resource-saving architecture, which qualifies Node.js especially for the operation of a web server. Ryan Dahl, the developer of Node.js, released the first stable version on May 27, 2009. He developed Node.js out of dissatisfaction with the possibilities that JavaScript offered at the time. The basic functionality of Node.js has been mapped with JavaScript since the first version, which can be expanded with a large number of different modules. The current package managers (npm or Yarn) for Node.js know more than 1,000,000 of these modules.
- Fast server-side solutions: Node.js adopts the JavaScript "event-loop" to create non-blocking I/O applications that conveniently serve simultaneous events. With the standard available asynchronous processing within JavaScript/TypeScript, highly scalable, server-side solutions can be realized. The efficient use of the CPU and the RAM is maximized and more simultaneous requests can be processed than with conventional multi-thread servers.
- A language along the entire stack: Widely used frameworks such as React or AngularJS or Vue.js, which we prefer, are written in JavaScript/TypeScript. If Node.js is now used on the server side, you can use all the advantages of a uniform script language throughout the entire application development. The same language in the back- and frontend simplifies the maintenance of the application and also the coordination within the development team.
- Flexibility: Node.js sets very few strict dependencies, rules and guidelines and thus grants a high degree of flexibility in application development. There are no strict conventions so that the appropriate architecture, design structures, modules and features can be freely selected for the development.
I've used both Vue.js and React and I would stick with React. I know that Vue.js seems easier to write and its much faster to pick up however as you mentioned above React has way more ready made components you can just plugin, and the community for React is very big.
It might be a bit more of a steep learning curve for your friend to learn React over Vue.js but I think in the long run its the better option.
Backbone.js
- Javascript structure135
- Models101
- Simple98
- Restful76
- Easy api59
- Flexible46
- Open source45
- Fast to pick up44
- Events34
- JSON25
- OOP8
- Lightweight2
- Collections1
- Easy customizable1
- Requires underscore.js1
related Backbone.js posts
The front end for Heap begun to grow unwieldy. The original jQuery pieces became difficult to maintain and scale, and a decision was made to introduce Backbone.js, Marionette, and TypeScript. Ultimately this ended up being a “detour” in the search for a scalable and maintainable front-end solution. The system did allow for developers to reuse components efficiently, but adding features was a difficult process, and it eventually became a bottleneck in advancing the product.
Today, the Heap product consists primarily of a customer-facing dashboard powered by React, MobX, and TypeScript on the front end. We wrote our migration to React and MobX in detail last year here.
#JavascriptUiLibraries #Libraries #JavascriptMvcFrameworks #TemplatingLanguagesExtensions
We are in the middle of a change of the stack on the front end. So we used Backbone.js with Marionette. Then we also created our own implementation of a Flux kind of flow. We call it eb-flux. We have worked with Marionette for a long time. Then at some point we start evolving and end up having a kind of Redux.js-style architecture, but with Marionette.
But then maybe one and a half years ago, we started moving into React and that's why we created the Eventbrite design system. It's a really nice project that probably could be open sourced. It's a library of components for our React components.
With the help of that library, we are building our new stack with React and sometimes Redux when it's necessary.
- It's a powerful framework109
- Straight-forward architecture53
- TypeScript48
- Great UI and Business Logic separation45
- Powerful, maintainable, fast40
- Amazing CLI39
- Great mvc33
- Powerfull Dependency Injection29
- Easy to build19
- All in one Framework16
- Opinionated, batteries-included approach15
- Schematics11
- Solid Standard Setup.10
- Structured8
- Performance7
- Complex5
- Only for single page applications4
- Builders3
- RxJS2
- Ng upgrade2
- React1
- Overcomplicated9
- Large overhead in file size and initialization time9
- Ugly code2
- CLI not open to other test and linting tools2
related Angular posts
When Redash was created 5 years ago we chose AngularJS as our frontend framework, but as AngularJS was replaced by Angular 2 we had to make a new choice. We decided that we won't migrate to Angular, but to either React or Vue.js. Eventually we decided to migrate to React for the following reasons:
- Many in our community are already using React internally and will be able to contribute.
- Using react2angular we can do the migration gradually over time instead of having to invest in a big rewrite while halting feature development.
So far the gradual strategy pays off and in the last 3 major releases we already shipped React code in the Angular.js application.
From my experience of the early startup world, a majority of companies these days use Node.js. Python and Go are the next biggest languages, but significantly smaller than Node.
However, if you're having trouble with the front end aspect of Django, using Node probably won't make that easier for you. You'll have a lot more options between front end frameworks (React, Vue.js, Angular 2) , but they'll definitely take more time to learn than Django's templating system.
Think about whether you want to focus on front end or back end for now, and make a decision from there.
- Elegant126
- Quick to develop97
- Great mvc83
- Great community82
- Great router73
- Values conventions, there is one-true way to organize52
- Open source50
- Components44
- Mvc framework34
- Handlebars.js28
- Htmlbars13
- Yehuda katz11
- Tom dale10
- Great logo10
- It's NOT Google or Facebook6
- manages large data sets on the front end easily5
- Convention over Configuration5
- Glimmer: react-like rendering engine5
- Organized4
- Fast4
- Enterprise4
- Intelligent4
- It rocks4
- Good docs3
- Fastest spinning circles3
- IE8 support3
- Easy and Quick to develop2
- Documentation is finally active and updated2
- Flexibility1
- Business wins1
- Comprehensive1
- Great for big apps/many devs because its organized1
- Growing community1
- For building ambitious Web apps1
- Dependency Injection1
- Stability without stagnation1
- Very little flexibility2
- Too much convention, too little configuration2
- Hard to integrate with Non Ruby apps1
- Hard to use if your API isn't RESTful1
related Ember.js posts
Simple controls over complex technologies, as we put it, wouldn't be possible without neat UIs for our user areas including start page, dashboard, settings, and docs.
Initially, there was Django. Back in 2011, considering our Python-centric approach, that was the best choice. Later, we realized we needed to iterate on our website more quickly. And this led us to detaching Django from our front end. That was when we decided to build an SPA.
For building user interfaces, we're currently using React as it provided the fastest rendering back when we were building our toolkit. It’s worth mentioning Uploadcare is not a front-end-focused SPA: we aren’t running at high levels of complexity. If it were, we’d go with Ember.js.
However, there's a chance we will shift to the faster Preact, with its motto of using as little code as possible, and because it makes more use of browser APIs. One of our future tasks for our front end is to configure our Webpack bundler to split up the code for different site sections. For styles, we use PostCSS along with its plugins such as cssnano which minifies all the code.
All that allows us to provide a great user experience and quickly implement changes where they are needed with as little code as possible.
Choosing a framework be it angular, react, ember or vue is personal preference. I would say start with each and build something that utilise state management (todo list perhaps?) and see which style you are comfortable with.
If you wants to get employed, React is a wiser choice. It also helps you build native mobile apps with react-native . If you are building enterprise app with alot of client-side data, nothing beats Ember.js ember-data.
If you are like me who is prototyping light-weight startup and would like to move fast and missing your first front-end learning (angular 1), go with Vue.js . NativeScript-Vue is the binding to build mobile native apps with it.