Need advice about which tool to choose?Ask the StackShare community!
Grails vs Rails: What are the differences?
Grails vs Rails: Key Differences
Grails and Rails are both web application frameworks that are designed to make web development faster and easier. While they have some similarities, there are several key differences that set them apart.
1. Language: Grails is built on top of the Groovy programming language, while Rails is built on Ruby. While both languages are dynamic, Groovy offers more powerful features and a more concise syntax, making it easier to write and maintain code.
2. Architecture: Grails follows a convention-over-configuration approach, where it automatically sets up the structure of an application based on a set of predefined conventions. Rails also follows this approach, but it takes it a step further by adhering strictly to the MVC (Model-View-Controller) architecture. This makes Rails more opinionated and enforces a clear separation of concerns.
3. Community and Ecosystem: Rails has been around for longer and has a larger and more mature community and ecosystem. This means that there are more resources, libraries, and plugins available for Rails, making it easier to find solutions to common problems. Grails, on the other hand, has a smaller and more niche community, which means that finding answers to specific questions or finding specific plugins may be more challenging.
4. Performance and Scalability: Rails is known for its performance and scalability issues, especially when dealing with high traffic websites. Grails, on the other hand, is built on top of the JVM (Java Virtual Machine) and benefits from its performance optimizations. This makes Grails more suitable for building high-performance and scalable applications.
5. Integration with other technologies: Rails has excellent integration with the Ruby ecosystem, which includes libraries and tools for testing, database management, and deployment. Grails, being built on top of the JVM, has strong integration with Java and the Java ecosystem, which means that you can leverage existing Java libraries and tools.
6. Learning Curve: Grails has a steeper learning curve compared to Rails. While Grails is easier to learn if you are already familiar with Java or the JVM, it can be more challenging for developers who are not familiar with these technologies. Rails, on the other hand, has a simpler syntax and a more straightforward learning curve, making it more accessible to beginners.
In summary, Grails and Rails differ in terms of their language, architecture, community, performance, integration with other technologies, and learning curve.
I'm really interested in building minimalistic web products with extra stuff like Stripe, MongoDB, solidity, WebAssembly and three.js.
Want to choose my backend lang but am unable to choose, my requirement is:
- fast dev
- minimal
- easy to learn
- good for saas
- huge community
- scalable
- fast and interactive
- good job market (not important)
If you want an ’easy-to-learn’ and ‘fast dev’ environment I would go with React.js, Node.js, and Firebase. This is probably one of the easiest tech stacks to develop and offers great scalability without creating a complicated database structure. Furthermore, it’s almost hard to develop a react application that isn’t lightning fast.
I am wondering which language would you guys suggest learning if productivity & "future-proofing" is the focus?
I have now 2 years of experience with React Native & Firebase and 3 years of experience with Next.js and ExpressJS. As I like the idea of separating backend & frontend I think as a solo developer the MVC approach will get you way further and overall I started second guessing the whole js ecosystem and its quality.
What I am currently considering the most is Django, even if I am giving up major productivity I think the opportunities Python offers with AI/ML & scrapping are way superior then Rails. I would like to know how much productivity would get lost by deciding on Django.
Python is simple to read. Easy to use and import libraries. It is widely used in many different application domains. It is very easy to learn compared to other languages.
Considering your background is in front end technology; why not try some other language that can help you become more well rounded? Besides, there are always more and more python jobs.
Django is very easy to learn. If you use Django, I recommend the Django-Rest-Framework. This will save you a lot of time. But you need to understand some Python first. I think Python is as simple as: interpreted, dynamically typed language where you use lists and dictionaries a lot.
I've inherited a monolithic Rails app for an MVP product. We're planning to slowly migrate away from RoR to build the remaining parts of the app. App requirements: - Video streaming w/ audio - Real time chat - User authentication & roles - Payment system Performance, scalability, and attracting dev talent(s) are important to our team.
I'm considering the microservices approach, SSR + CSR & caching with Next.js (prefer Svelte-kit but it's in beta). I also prefer to keep this a full JS household. What other JavaScript frameworks/libs would you recommend? Keep in mind the existing RoR will not be deprecated. We'll be consuming the APIs and slowly moving away from them until they can safely be deprecated.
Moving from Rails will reduce development velocity (if you want to have easy support and update the app) and will require more skilled (expensive) developers to support it.
Without previous experience (5+ years) do not suggest moving to node.js. That code will easily become hard to learn and support.
You always can implement microservices with Ruby, but this approach should be considered only after Series-A and when you will have more than 5 developers and dedicated SRE/DevOps.
I see it's been some time since this was posted, but I'm glad you are migrating to Next.js 🎉!
Me personally, I would run an Express.js backend so that frontend and backend logics don't feel blurred, especially if you want to attract more developers to your project. Keeping frontend separated from the backend makes for a healthier workspace ecosystem and often confuses people less. Furthermore, implementation is a lot easier and later on as you move from RoR to an Express.js server there won't be too much confusion as to how certain parts mesh together.
Based on the features you're looking at I would consider using websockets (WSS or Socket.IO) for the chat application or rolling that with features from WebRTC, which you would need to support video streaming anyways. For authentication you could look at Auth0 which has some very nice libs for authentication or you could rig up your own stitching individual OAuths (Google, Facebook, etc.) along with a simple User/Pass signup that you manage in your database. For payment I would consider using Stripe, it's very popular in the JS ecosystem right now, has lots of documentation and features, and is also pretty cost-effective.
I know it's been some time since you have posted this and you have already made some decisions, but if you (or anyone else reading this) has any question feel free to let me know :)
Hi everyone! I'm starting a personal project that I've been postponing for a little while and I'm starting with the backend first.
It's an app that needs to query open APIs (It could go up to a hundred APIs) and do filtering and other manipulations onto the data and then store it in my own database. So basically, the end result medium/long term is a lot of data!
Besides filtering/storing data from other APIs, the API will interact with my client application. I should note that the client app attempts to give real-time information.
Question: I would want to launch the API within 6 months as I'm also planning to make it available for other devs through platforms like RapidAPI. With all being said, my question is twofold:
Which backend framework would allow me to do these operations with the best response time possible?
Which framework would be the easiest to deal with deployment on AWS?
Background:
I have a background in Spring since I'm using it at work, I have none in Rails and Django but I don't mind trying something new as long as the learning curve isn't crazy. I know python but not Ruby. Beginner on AWS and choose that one after some research.
Thank you very much, sorry it was a bit long. Cheers
The most relevant part is the central architecture more than the specific backend. For me, it makes sense to go for an event-driven solution. In this case, an event is emitted on every new data, and one or more listeners react to it. In AWS, you can easily get this by storing your data in DynamoDB, which is pretty fast, and have as many lambdas working on the received data (here you can find more details). This way, you keep your worker(s) busy fetching data while others consolidate it. I wouldn't get too crazy on the lambdas, and I'd start with one as there will be only one client by your description. My only concern is how similar the APIs you're consuming are. Depending on that, it may be easier to have different lambdas by target API. My only note on the backend language is that if you want low latency, I'd discard Python and Ruby and choose Go (I know that is not in the list, but given that you're open to learning a new language, you could give it a try). It is easy to learn, has excellent performance, and is the only Lamdba runtime with an X (1.X) in the supported language, making it a great choice.
Which is better of Laravel, Rails and Django for creating great products quickly?
Which is better for creating open source apps that others might want to contribute to?
I want a mature tool for creating web apps that qualifies for:
- Quick prototyping
- Easy to get to production level for backend
- Maintainable and buildable by one person alone
- Enforces conformity, so others can easily read and contribute to the code, making successfully open sourcing possible
- Works well with React
- Has a mature and fairly stable ecosystem for the basics (auth, storage, db, image handling, backups, change history, etc.
- Has an ecosystem that will still be alive in 10 years, responding to changes.
I would have to learn Ruby, Python or PHP for each, so that factors in too.
I'm proficient in React and Node.js, but I feel the node backend ecosystem is too immature with a million different ways to do everything, and too many decisions to make, too much wiring to get everything to work together, and too many packages that end up not being supported a few months down the line.
Which would you choose for me to learn?
Comparing them end-to-end, Rails comes the most productive in my opinion. But there are bolder parameters you may consider. i.e. no one switches from Django to Rails to improve productivity and vice versa (probably from Laravel to one of those two).
The language's productivity also matters, which both Ruby and Python are better for that.
There is a philosophical difference between #Django and #Rails :
Django supports the "Explicit over Implicit" idea, making it easier for newcomers to understand what's going on. This idea also has downsides. This allows beginners to start working with Django without even learning Django and best practices and defer learning by using references like Stackoverflow.com, which is not a good idea because you potentially don't know things that you don't know! Also, you may find many different project styles.
On the other hand, Rails support the "Convention over configuration" and Scaffolding idea. It's easier for a Rails developer to be added to a new project or just review a random Rails project. Everything has a default and also it has some downsides as well. e.g. As a beginner, everything feels like magic in Rails, and you don't understand what is going on and how Rails understand while you didn't "explicitly" say what do you want sometimes.
Conclusion: Rails and Django are more productive and you can build projects on your own quickly (many giant startups launched this way!).
Node.JS isn't immature, also sometimes shows better performance comparing the mentioned alternatives. But if you suffer from "a million different ways to do everything" and "many decisions to make", Take Ruby on Rails for sure.P.S: for learning RoR I suggest the book/video from Michael Hartl.
I picked Django because we use it at work. But honestly, if you don't know any of them, I would look at the jobs around where you live and learn the one that either has the most jobs posted or if you can look at the trends the one that is growing the number of jobs the most.
All three would satisfy your needs and all three are good choices. Dotnet core would also be a good choice, again if there are jobs in your area for said technologies. If you literally don't care about this for employment, learn them all and just do it in alphabetical order :)
Note: I think you are wrong about Node being too immature - there are also MOSTLY standards for everything you want to do on the backend that have not changed for many years.
Rails uses too much magic and sugar. Laravel is something from the previous century. I'd say Django can be well balanced choice. I have extensive experience with all three. So, this advice based on practical projects
I recommend Ruby/Rails. I write the text in question answer form:
Quick prototyping
Yes you can use the prototyping in Rails or not. And this can be realized by adding any of testing framework like Cucumber or RSpec for example. Writing the test you can work on the application prototype without a change real code in production, or even development environment.
Easy to get to production level for backend
Yes it is easy, you are able to use the capistrano gem with its modules, if required, to deploy application to production within a day.
Maintainable and buildable by one person alone
Since the Rails gets on itself the main code part of a data processing, you are able easily to generate the required code with build-in Rails or external gem generators, and to merely maintain the your code, if you would cover it with a test of selected test framework.
Enforces conformity, so others can easily read and contribute to the code, making successfully open sourcing possible
As far as I said you can barely control a contribution to your project with using the test covering frameworks, to keep conformity the project.
Works well with React
You can use React along with any JS NPM module easily using webpacker gem.
Has a mature and fairly stable ecosystem for the basics (auth, storage, db, image handling, backups, change history, etc.
Of course the Rails framework is supported by many three-side gems, which can be found at rubygems, that support the authentication (devise), storage feature (fog), db (pg/mysql/sqlite3), image handling (rmagick), backups (backup), change history (history)
Has an ecosystem that will still be alive in 10 years, responding to changes.
Ruby/Rails with the RubyGem ecosystem is actively envolving and not plan to be collapsed and abandned with of development both Ruby language and Rails framework.
So, you can freely and fearlessly start using the Rails framework as server side base for your project.
DJango after a little practice, with migrations and support to a lot of libraries and modules is very efficient to create small projects.
Edit: Between Laravel, Django or RoR (Ruby on Rails)
In the past few months, a project we're working on grew up quite fast. Since we're adding more and more features, I'm considering migrating my Express/TS REST API towards a more solid and more "enterprise-like" framework. Since I am experienced with TypeScript but not so much with Rails nor Play (Scala), I'd like to have some advice on which one could provide the best development experience, and most importantly, the smoothest paradigm transition from the JS/TS world. I've worked on some personal project with Rails, but I've found the Ruby language really distant from what the TypeScript ecosystem and syntax are, whereas on the opposite - during the brief tours I've taken in the past weeks - it's been a pleasure coding in Scala. Obviously, there are some key differences between the two languages - and the two frameworks consequently - but despite all the ROR automation and ease of use I don't despise at all Scala's pragmatic and great features such as static typing, pattern matching, and type inference. So... Please help me out with the choice! Regards
I don't have the Scala experience to compare the two, but I can say that Ruby is a wonderful language. For procedural programming where you don't need a lot of concurrent execution threads, it's superior to Node.JS in my opinion. All of the concepts from Typescript have equivalent syntax in Ruby, but there are fewer symbols (e.g. () => { ... }); ) and more keywords (eg 'do ... end'). It's a very flexible language and allows for a lot of different approaches to how it's written, so coding standards and careful organization is important. In the long run, however, you'll find it quicker to debug than Node.JS and just as powerful.
If you are comfortable with TypeScript, why not evolve to a C# ecosystem? Asp.Net Core + Entity Framework is a mature and well supported technology. As far as I can see in the enterprise market, the most adopted choice is still Java. So, maybe you may have a look to SpringBoot - and ultimately Quarkus.
If software performance is your top priority, then Scala/Play is probably best. If developer productivity is your top priority, then Ruby on Rails is the best choice in my opinion.
The Rails framework is batteries-included. The framework takes care of many things by default so that you don't have to. Logging, security, etc. It's also well-integrated; for example, controllers understand models out of the box. I had a better experience with RoR than with Play.
On the other hand, Scala and the JVM are more performant in general, so they can scale to serve more requests per second on the same hardware.
If you're considering serverless functions, then Scala is probably a better choice because it would be faster to load, giving you better economics.
This is advice regardless of your background and requirements. The Play framework has a terrible and complicated design, don't risk it. I even suggest Spring and Kotlin over it! You can use Scala for small services and Data Engineering stuff and benefit optimizations and threading of JVM. RoR, on the other hand, has a huge development speed, which I believe is a big advantage cause you can handle performance bottlenecks later. Also, Scala has another downside, which is featureful in terms of OO and FP paradigms, which makes anyone write code freely with any personal style and makes it a problem in a team, Hence a coding style has to be defined if there would be Scala development team.
I'm going to do an independent study with React for school, and I'm looking to build a full-stack application. I have lots of experience with react, but everything else I'd need is somewhat foreign to me. What I'm looking for is to provide a back-end for a React application.
I'm trying to find a back-end framework that can provide and integrate with almost everything I need (database, API, authentication). I will also need to be able to host everything eventually online rather than just locally on my computer. I don't want to use something that is just click-and-go: I want to learn a lot but find something that has much built in functionality, so I don't have to completely re-invent the wheel.
Does anyone else have experience with a stack you'd recommend that is a happy medium of helpful features while still requiring you to understand and implement the functionality yourself? Something well documented (e.g., it's easy to find documentation regarding putting all the pieces together) would be great.
Thanks in advance!
Greate documentation, lot's of info on StackOverflow and it's easy to learn, a lot of things it's already implemented on the stack. It's based on Ruby which is stable and constantly evolving.
Ruby/Rails have a lot of gems(libraries) that will allow you to connect to many DB systems, implement JWT or use a library for authentication.
I have a lot of API's created in Rails that respond to website and mobile apps, and you can create your first one without a lot of stress, responding with JSON easily.
You can use VSCode has good support for ruby and you will have all syntax help etc, I use Atom but I don't have the syntax support, didn't found a good package for that.
The most popular stack that comes to mind for your case if MERN ( Mongo, Express, React and Node) I would use Nodejs + Express for backend. Easy to build dynamic and powerful REST APIs. For DB, it would be Mongo DB and front end can be React + Redux (for global state management). Plus NPM has a ton of packages for most cases. PS : Webstorm (free for students) or VS Code ( free for all) for IDE
I would take either Rails or Node for your problem.
Rails is a great framework: super complete in regards of testing frameworks, authentication libraries, great community support.... but I would say that the latest versions are a bit of a mess for newcomers, because of the way they manage assets: if the assets are served by the framework(Assets Pipeline) vs using Webpack .
If you are already familiar with React, Node is another great framework that will require a bit more effort on selecting the dependencies but for your use case seems a great candidate.
In regards of what you are commenting about learning during the process, both can be Dockerized pretty easy and you can spend some time digging on the lifecycle of putting it into production. Rails has a ridiculous easy way of deploying with Heroku avoiding any kind of work, but if you want to get your hands dirty you can deploy either of the frameworks on a Dockerized environment to any cloud provider you like. That part is really interesting too, and if you are interested on the Devops side, I would say that Node is a bit easier and more convenient(smaller image sizes and times to build) than Rails. All in all:
Rails pros: stable framework, great community support, great testing utilities. Rails cons: How they manage the assets lately(Assets Pipeline vs Webpack), dockerize the app.
Node pros: You are already familiar with Js, simple, easy to put in prod allowing to spend time in the Devops side. Node cons: Dependency management in Js environments is a pain in the ass
Rails is an easy framework to pick up, and you'll get to love all of the magic it does for you. Some of that can be a little confusing at first but once you've got acquainted, this is part of the productivity Rails offers as opposed to other languages or frameworks that sometimes tend to require developers to waste a ton of valuable time setting up their own boilerplate when starting to work on a new project. More pragmatically, Rails is still extremely popular at both startups and at large companies, you can use it to power web applications, or backend APIs, and this will be extremely valuable on your resume. There also is a very large/rich set of libraries (called gems) that will allow you to focus on your actual project/product, rather than rebuilding what already exists. I'd recommend you go with the latest versions of Ruby (3.0) and Rails (6.1.1) so you are from the get-go learning them in their most current form.
Node.js is great if you already know Javascript. If not, JS is pretty easy to learn. There are many resources and tutorials online for JS and Node. ASP.NET (Core) is a good option if you know C# or need high performance. Node.js isn't a complete framework like .NET, so you need to add Express or another HTTP server, and Database connectors etc.
Although not entirely confident, as I've never used Django and I've not used ASP.NET since 2.0, but given your requirements, at first thought, I'd go with Rails.
Yet, may I ask if have you considered some BAAS such as Firebase, Hasura and the like? Although I've admittedly suffered a bit with Firebase - I'm not totally sure if I've used it correctly, tho. But I've heard really awesome things about Hasura. This slant compairson shows some Firebase's alternatives that I've never heard. In your position, I would have a look.
Cheers.
I recomand to take a look at this https://dev.to/andrewbaisden/creating-mern-stack-applications-2020-4a44
Currently working on my company's new saas, the main goal is to manage content and user. I'm familiar with the rails framework and how it is easy to code and deploy. The thing is I'm the only dev on the project, and in terms of the tech stack, there is no preference. However, because Node.js is everywhere and there is enough dev on the market, I am stuck between choosing Rails or Node.js. I don't mind implementing Vue.js or React on the frontend, but I need a solid argument to explain to people that aren't necessarily tech-savvy as to why we should choose Rails over Nodejs.
You are probably referring to ruby on rails for web development and nodejs for building the backend. Nodejs has frameworks such as express and next which not only provides a minimal code to build a backend but also gives the flexibility to try and experiment with the framework choices. For example you can have express framework + Passport for OAuth .... etc. The flexibility and the constant improvement of the language provides a good reason to opt for nodejs. Nodejs uses javascript which makes your code uniform when you are working full stack i.e react in front end and nodejs in backend.
I'd use the following metaphor to non-technical people. Rails is like a prepackaged toolkit, which can get most of the common tasks done fairly with ease. Whereas, node.js with whatever backend framekwork of choice, is like a DIY toolkit assembled by mix-and-match different tools in a large tool shop. Of course, at times DIY toolkit can do better on specific tasks. Given that you are the only dev on the project, I'd assume that the resource is fairly limited. And looks like you are not building some next-gen super duper fast smart application. So Just go with the prepackaged toolkit then. Rails is a very opinionated framework, there're pros and cons to it. But thanks to that, many of the gems are coded with it in mind. For example, they are all designed with same naming convention. Many will work well together out-of-box, for example devise and cancancan. Besides, many stuff are built in the framework. For example, logging utility, csrf protection, session encryption, etc. Yes, many of those stuff may not be useful or necessary at the beginning of the project life-cycle. However, down the road, there is a good chance you will need some of those. And the moment you realize that you already have it, it's so delightful. In addition, it's usually easier to debug a rails app than a node app in my experience. Personally, the cases where I would pick node.js over rails would be projects either require a) high-performance, or b) certain core functionality that has been implemented by some node packages but not by any ruby gems. In term of performance, node has a clear advantage over any other major web frameworks, except the ones built with go. It's simply a language feature. Node allows developer to easily write code that runs db query, external api calls, or other stuff of that nature in parallel. And that is THE MOST COMMON performance bottleneck of web applications.
Rails is currently a very mature and feature complete framework.
It's the ideal one if you're the only dev for your project because you get so many things already baked-in the framework that you'd only need to deeply care about specific stuff.
I won't say any NodeJS framework isn't good enough but in my experience with NodeJS frameworks you have to code a lot of the things Rails already provides. There's many people in Twitter and IRL asking for a "Rails for JavaScript" framework.
And you know? In the early stages of any project we have to validate it first with real users/customers. With Rails you can get to production real quick and fast.
I'm going to mention some of the features you get from day 1 when you run rails new app_name
:
- File uploading with Active Storage
- Rich text editor with Action Text
- Emailing with Action Mailer
- ORM, migrations, validations with Active Record
- Web sockets with Action Cable
- Internationalization
- Modern frontend stuff with Webpacker
and more.
The JavaScript community is on its moment, growing and gathering more people everyday but the Rails community is also a big one and there's always going to be a Rails developer to hire whenever you're ready to hire someone.
I suggest you to go with Rails because is a good choice, gives you less things to worry about and it's a very good and mature framework.
I hate to admit it, because I loved my time with Rails (and I still love the framework), I have a hard time justifying new Rails applications these days. Core team has made some tragic design decisions, and developers just don't perceive it as being "cool" any more. The latter is a terrible metric for which to base a technology decision, but I think you'll find it more difficult to recruit additional engineers if you choose Ruby on Rails.
Without knowing too much of the details, Node/Express (ideally with Typescript) seems like a better solution here, given you'll be building out the front-end in Vue or React. It might be worth looking at NestJS, as it's the closest I've seen to a well-formed opinionated framework on the Node side of things. We're also fans of Objection ORM.
I hope that's helpful!
I need a solid argument to explain to people that aren't necessarily tech-savvy as to why we should choose Rails over Nodejs
Hi Max, it sounds like that you are proficient in both stacks and probably have a higher expertise in Rails (correct me if I am wrong) and since you are the only dev on a project, a good argument that comes to mind is probably the velocity and maturity (enterprise grade, battle tested in production) that Rails provide with proven success stories in the tech industry such as Airbnb, Stripes, Shopify to name a few. You can also make the argument that Rails is great to run the backend and React+Vue (and nodejs for tooling) is ideal for the front-end development (see or find companies example that use both). You can also build and show a prototype using both and share your experience which could help you find and forge the selling points to those non tech savvy folks, why not.
Eventually, are you going to have other developers on your project? if yes then you will need to take in account, onboarding and ramp up to contribution time when they are hired.
IMHO, I am not a fan of the debate Rails vs Nodejs, they are just tools at the disposal of the developer it's just a matter of figuring out what makes the most sense.
Let me know if you wanna discuss further, happy to help out!
ps: markdown preview on stack share... no good.
Rails has advantages over node.js (specifically express) when working a more complicated backend. While Express has some speed advantages to Rails, this is mitigated if your software is more CPU intensive.
Hi Community! Trust everyone is keeping safe. I am exploring the idea of building a #Neobank (App) with end-to-end banking capabilities. In the process of exploring this space, I have come across multiple Apps (N26, Revolut, Monese, etc) and explored their stacks in detail. The confusion remains to be the Backend Tech to be used?
What would you go with considering all of the languages such as Node.js Java Rails Python are suggested by some person or the other. As a general trend, I have noticed the usage of Node with React on the front or Node with a combination of Kotlin and Swift. Please suggest what would be the right approach!
Use the language which works well for the developers you have or have available. If you're starting, building a first iteration is far more important than worrying about what language might be best to solve a problem you may never have.
When hiring, look for developers, not "node developers" or "java developers" having people who recognise and are willing to adapt means you can have the flexibility you will need to solve as-yet unforeseen issues. Hire people who are wed to a specific language and you will be bound to that language, regardless of whether it's most appropriate or not.
For online banking, it'll be less computation intensive and more data intensive. So, Rails will be better than Python. I'll not recommend Node.js as it's not as scalable as those. If I had to choose indepently I would took Go.
Typescript reduces many errors and makes potentially big app more maintainable. For banking app typed language is must have, so if not node than it could be anything typed, but not python or ruby. Also you can search benchmarks by yourself - ruby is the slowest language in the world, python comes next, javascript is on top of interpreted languages by speed.
HI Shivam, If you the only person who is going to develop the full application then I will suggest you to go for Node.js because you will have to deal with one language only i.e. Javascript. And if you are thinking about scaling then do not worry. Nodejs with mongodb make good application. Capital One bank, Paypal, Linkedin and so on companies shifted themselves to Nodejs. Even if you go for Ruby, it has GVL which again makes it work in single thead. If you want to manage concurrent requests in Ruby then you have to manage by introducing Rubinius/jRuby. If we talk about the deployment of Nodejs, it require less resources as compare to other. I have deployed inventory solution right now using Reactjs with Node.js stack and it is pretty much good. I have also deployed apps in Ruby as well. However, node is fast as compare to Ruby and you can scale it easily. I am not saying Ruby is bad. I work in Ruby as I told you above. But these are the real facts.
You can checkout this link :- https://softwarebrothers.co/blog/companies-that-use-node-js/
Since it's a banking app, I'd advice you go with Python for the backend because of the data analysis you'd be doing in your app. I see you doing some data analysis since it's a banking app. Python is a powerful language for data analysis. And for web, yes I'd advice Node with React, and for mobile, Node with a combination of Kotlin and Swift. Don't even try going hybrid for this kind of application. It's best going native.
As others mentioned, the problem domain is around data. From my experience, data means strongly typed entities. It might be good however to start off with a dynamic language such as Python (with Django) just to build a prototype, but once the models have been proved to be valid I'd go with statically typed language such as java/Go (I prefer Go but that's a whole different conversation) as you get compile time guarantees for type safety.
An alternative (or addition) to all of the above is the use of 'strong protocols', such as Protocol Buffers, Avro, Thrift and the likes. In this case you get type safety and stability between communicating backend services, while deciding and changing on whatever backend service language you want. That goes to say that your problem is not related to programming language decision but to a much profound understanding of what's important for the business to be created and be valuable.
As a general note, I don't think you should go, if you've got commercial aspirations, with any language that you'd have hard recruiting people who actually know what their doing. In Israel it would mean take Kotlin out of the equation
The reason why companies are switching to nodeJS is because it unifies all development under a single language.
If you are a one man team you can start developing anywhere on the stack without the overhead of switching languages at each layer. If you have a large team, your DBAs, your core service team, your application team can all read each others code.
You can build a serverless backend using nodeJS and cloud services( AWS, Azure, etc.) that is extremely scalable. A front end framework (ReactJS(Web/mobile), ReactNativeJS(mobile optimized) all in Javascript. If you need to optimize performance for mobile further you can contract an iOS Developer to build in Swift or an Android developer to build it Kotlin and give them keys to use your nodeJS apis.
node is convenient.
You should not go with react,kotlin and swift those are very colourful languages but java ,node.js etc are colourful yet they have depth. You should only go with kotlin if you want to use android studio it is highly compatible. So its your choice . May you choose the best
Graphul is an Express inspired web framework using a powerful extractor system. Designed to improve, speed, and scale your microservices with a friendly syntax, Graphul is built with Rust. that means Graphul gets memory safety, reliability, concurrency, and performance for free. helping to save money on infrastructure.
A developer and project manager from our team X says the following about our use of Rails at i22:
"We use Rails to build stable and flexible backend systems. Rails is extremely good for managing data structures and quickly setting up new systems. It is the perfect base for most use cases."
I asked the same Team X member why the team prefers to work with Ruby on Rails, rather than Python and Django:
"Because Python is a scripting language and from my point of view not suitable for building stable web services. Python is for me rather good for scripts and fast small tools. Not for stable business applications. And if I want it fast I prefer Go."
In 2017, we decided to move away from Backbone and embrace a relatively new tool which was taking the industry by storm, React
. Since Backbone was no longer actively maintained and its popularity was falling, it made sense to adopt a tool that was on the rise and promised improved performance, developer experience and delivery speed. In addition, it became easier to hire Frontend Engineers as the talent pool greatly increased. Nowadays, React is the framework of choice across Vinted.
Typescript
entered the picture at a later stage. We placed our initial bet on Flow but it soon became obvious that the industry prefers Typescript. In 2019, we migrated to Typescript and never looked back. Having a strongly typed language in our frontend brought confidence to the engineers and greatly reduced the number of bugs.
Next.js
is the newest addition to the stack. Vinted is currently a Rails
monolith and React on Rails is used to render views. In order to transform Vinted to a single-page application (SPA) and split backend from frontend, we decided to adopt Next.js. Among the options considered, Next.js offered the most comprehensive feature set, good support for Server Side Rendering (SSR) and a vibrant community. We also expect that splitting the client-side would lead to improved developer experience and faster builds.
I was considering focusing on learning RoR and looking for a work that uses those techs.
After some investigation, I decided to stay with C# .NET:
It is more requested on job positions (7 to 1 in my personal searches average).
It's been around for longer.
it has better documentation and community.
One of Ruby advantages (its amazing community gems, that allows to quickly build parts of your systems by merely putting together third party components) gets quite complicated to use and maintain in huge applications, where building and reusing your own components may become a better approach.
Rail's front end support is starting to waver.
C# .NET code is far easier to understand, debug and maintain. Although certainly not easier to learn from scratch.
Though Rails has an excellent programming speed, C# tends to get the upper hand in long term projects.
I would avise to stick to rails when building small projects, and switching to C# for more long term ones.
Opinions are welcome!
Starting a new company in 2020, with a whole new stack, is a really interesting opportunity for me to look back over the last 20 years of my career with web software and make the right decision for my company.
And, I went with the most radical decision– which is to ignore "sexy" / "hype" technologies almost entirely, and go back to a stack that I first used over 15 years ago.
For my purposes, we are building a video streaming platform, where I wanted rapid customer-facing feature development, high testability, simple scaling, and ease of hiring great, experienced talent. To be clear, our web platform is NOT responsible for handling the actual bits and bytes of the video itself, that's an entirely different stack. It simply needs to manage the business rules and the customers experience of the video content.
I reviewed a lot of different technologies, but none of them seemed to fit the bill as well as Rails did! The hype train had long left the station with Rails, and the community is a little more sparse than it was previously. And, to be honest, Ruby was the language that was easiest for developers, but I find that most languages out there have adopted many of it's innovations for ease of use – or at least corrected their own.
Even with all of that, Rails still seems like the best framework for developing web applications that are no more complex than they need to be. And that's key to me, because it's very easy to go use React and Redux and GraphQL and a whole host of AWS Lamba's to power my blog... but you simply don't actually NEED that.
There are two choices I made in our stack that were new for me personally, and very different than what I would have chosen even 5 years ago.
1) Postgres - I decided to switch from MySql to Postgres for this project. I wanted to use UUID's instead of numeric primary keys, and knew I'd have a couple places where better JSON/object support would be key. Mysql remains far more popular, but almost every developer I respect has switched and preferred Postgres with a strong passion. It's not "sexy" but it's considered "better".
2) Stimulus.js - This was definitely the biggest and wildest choice to make. Stimulus is a Javascript framework by my old friend Sam Stephenson (Prototype.js, rbenv, turbolinks) and DHH, and it is a sort of radical declaration that your Javascript in the browser can be both powerful and modern AND simple. It leans heavily on the belief that HTML-is-good and that data-* attributes are good. It focuses on the actions and interactions and not on the rendering aspects. It took me a while to wrap my head around, and I still have to remind myself, that server-side-HTML is how you solve many problems with this stack, and avoid trying to re-render things just in the browser. So far, I'm happy with this choice, but it is definitely a radical departure from the current trends.
I have used both the tools . Both of them are super awesome , very reliable and their learning curve is also super easy. But, the reason I choose Ruby on Rails over Django is the fact that the dependency injection is super easy in Rails than Django. What I mean is the fact that, Django requires a lot of import statement to do a lot of work, which remembering is not so easy and even after that you may need to write a lot of code. But Ruby on Rails uses gem to add addition feature or dependency in the project. Which requires just copying the gem statement from github and pasting it in the Gemfile, then running bundle install(these days just bundle works super fine). And there you are with the new feature in your app. You can see this with the example of Authentication, where in Django you require several steps like adding class based views and many more, but in rails it's just as easy as installing the 'devise' gem . And if you want to make it beautiful use bootstrap_template gem to make it look prettier. Now with Rails 6 , Rails is a total developer's fervent friend because it has come up with features like Action Mail and Action Text.
Since I came from python I had two choices: #django or #flask. It felt like it was a better idea to go for #django considering I was building a blogging platform, this is kind of what #django was made for. On the other hand, #rails seems to be a fantastic framework to get things done. Although I do not regret any of my time spent on developing with #django I want to give #rails a try some day in the future for the sake of curiosity.
As a small team, we wanted to pick the framework which allowed us to move quickly. There's no option better than Rails. Not having to solve the fundamentals means we can more quickly build our feature set. No other framework can beat ActiveRecord in terms of integration & ease-of use. To top it all of, there's a lot of attention paid to security in the framework, making almost everything safe-by-default.
When I started on this project as the sole developer, I was new to web development and I was looking at all of the web frameworks available for the job. I had some experience with Ruby on Rails and I had looked into .net for a bit, but when I found Laravel, it felt like the best framework for me to get the product to market. What made me choose Laravel was the easy to read documentation and active community. Rails had great documentation, but lacked some features built in that I wanted out of the box, while .net had a ton of video documentation tutorials, but nothing as straightforward as Laravels. So far, I am happy with the decision I made, and looking forward to the website release!
Pros of Grails
- Groovy56
- Jvm40
- Rapid development38
- Gorm37
- Web framework30
- Open source25
- Plugins21
- Extensible17
- Easy17
- Dynamic14
- Clean architecture (Dependency Injection)6
- Gradle6
- Clear what everything does, lots of options5
- RAD4
- Agile4
- Great documentation4
- Android3
- Spring3
- Easy setup2
- Java web apps with steroid1
Pros of Rails
- Rapid development858
- Great gems652
- Great community606
- Convention over configuration484
- Mvc417
- Great for web348
- Beautiful code343
- Open source311
- Great libraries270
- Active record261
- Elegant108
- Easy to learn90
- Easy Database Migrations88
- Makes you happy82
- Free75
- Great routing62
- Has everything you need to get the job done54
- Great Data Modeling41
- MVC - Easy to start on38
- Beautiful38
- Easy setup35
- Great caching26
- Ultra rapid development time25
- It's super easy22
- Great Resources17
- Easy to build mockups that work16
- Less Boilerplate14
- Developer Friendly7
- API Development7
- Great documentation6
- Easy REST API creation5
- Quick5
- Intuitive4
- Great language4
- Haml and sass4
- Easy to learn, use, improvise and update4
- Metaprogramming2
- It works2
- Jet packs come standard2
- Easy and fast2
- Legacy2
- It's intuitive1
- Convention over configuration1
- Easy Testing1
- Cancan1
Sign up to add or upvote prosMake informed product decisions
Cons of Grails
- Frequent breaking changes3
- Undocumented features2
Cons of Rails
- Too much "magic" (hidden behavior)24
- Poor raw performance14
- Asset system is too primitive and outdated12
- Heavy use of mixins6
- Bloat in models6
- Very Very slow4