It depends.

From times to times I asked or was asked that same question. Technology aside, it's important to consider the skills and expertise that the dev team has. Whether you use language A,B or C or framework X,Y and Z, if your team has a strong background and experience with something make it count too.

I would recommend Go simply because as you mentioned, it's super light. No need to bring in the whole .NET suite to get a simple REST API up and running. Even if your API is a bit complex, Go should be able to handle it.

I started out with C# and .NET and I loved it. In my opinion, it was the perfect way to start learning the fundamentals of software development however I always felt like I was at a disadvantage when I was doing .NET development. Granted, .NET Core is now open-source and cross-platform, but I moved to Node.js simply because it is incredibly popular. I never thought I'd learn to love JavaScript it the way I did with C#, but I learned to love it pretty quickly, especially once I started using TypeScript. You get all of the benefits of C# and JavaScript all in one. If you've built a REST API with Python/Flask/Django, you'll be able to learn Node.js/Express/TypeScript well enough to migrate your API very fast and it's incredibly easy to host for free on any number of services.

I'm new to Go, I've got very little experience but the 'feel' of Go, isn't like Python in my opinion. Go has a pretty steep learning curve, much steeper than C# in my opinion. So if you are willing to consider Node/Express/TypeScript, I think you may really like it. If you're picking between Go and C#, I'd go for C# as of today, but once I am more comfortable with Go (which I anticipate being a slow process) I may change my mind.

At this moment in time, in late 2020- Node/Express/TypeScript feels like the obvious choice to me as a former C# developer.

The best language for you is the one that you know best!

Its a bit of a guess, but from your question and the difficulties you have with Python it seems to me the problem you describe is the manifestation of a bad design/architecture/code quality. These are not the problems of a language itself!

The experience you gained over the past years with your current programming language will outmatch any benefits of another language that you start from zero.

Because in the end of the day languages aren't all that different when it comes to fullfil the same task, it's more the tools, framework and ecosystem for a particular problem that make a difference.

I worked with Java, C#, Go and recently in Phyton, and I would choose Phyton over Go for WebApps, even I like compiled languages more. Go is a very simple language, I would even say maybe too simple. I can't stand all those go boilerplate if err checks, the broken filesystem, the date/time mess and many more things that aren't actually relevant for business application at all. Go has its advantages but not for WebApps.

Keep the lang and improve your skills and architecture you will benifit more from it than from a new language.

I recommend Go for backend. It's younger than C# doesn't mean it's not mature. It's already mature enough to be run on production. You can see there are already many companies in the world adopting Go as their backend business logic or tooling. I can name a few like Github, Shopify, uber, twitch, and many more. It's easier learning curve, low entry barrier, better performance than C#, better memory consumption than C#, since there's no VM/runtime needed. It's suitable for large scale system and large codebase for readibility and long maintainability. It's simpler than C# since no class, inheritance(this can cause hard to maintain software), exception, etc. You can still implement OO way in Go without those feature. Simple file structure, only main files and package files. It compiles to single binary and easy to deploy and work around it, unlike C# who compiled to IL and you need to wrap all those IL files to be run inside separated web server(even .Net/.Net Core platform provide built-in web server). For libs, don't worry, there are many open source libs you will found on Github and already adopted by many companies. Go is employed in personal, startup, even corporate level.

I suggest Go because it has a simple and clean ecosystem. The language is simple. You don’t need complex configs or installs either. You’ll be up and running very quickly. It doesn’t have as much as .NET but its standard library is more than sufficient for RESTful APIs. Concurrency is much, much easier too.

C# I’d definitely recommend later on. The .NET framework, especially core, is extremely powerful and there’s little you can’t build with it. Go won’t take you long to be productive with.

I have some systems on production using both languages. I tend to use golang if the API is small or medium size, but if I am going to build a large system definitively I use c#(asp netcore).

If you want to stick with python you may want to consider Fastapi. It uses Pydantic to give you strongly typed models and validation. It generates openapi docs for you out of the box. They have good documentation as well and they claim it is really fast.

The database your are going to connect and the needed libraries could decide. Because both are awesome languages.

I would recommend C#, particularly Simplify.Web web-framework. C# is easy to start with (especially .NET Core). Simplify.Web is also easy to start with, no extra setup required for simple API, but on the other hand you have power of C# and full control over your API with ability to extend.

Currently, I have decided to use Python and JavaScript (especially React and Node.js) for any of my projects. Well, I have used Python with Django for a lot of things, and I would certainly recommend Django to anyone, due to its high secure authentication and authorization inbuilt system, a ready to use admin platform, template tags, and many more. Well, I guess that you would like to use Python to create the backend of your application, an API, and React Native for the frontend. Python and JavaScript (React) are on the trend these days and have a huge community, so there are many resources, tutorials, great documentation. I have not really heard anyone using Flutter and Go for applications these days, so I would not recommend it to you, it would make your life much more difficult.

Hope that helps, and good luck with your project!

I'm typically agnostic when it comes to picking languages. Whatever gets the job done, but, in this case, to figure out what's involved with what you want to do, it's going to be much more than just picking programming languages for your client and backend interfaces.

So, I'm recommending you use Flutter+Firebase as a way to figure out what you need to get done. It supports both iOS and Android out of the box, introduces you to a bunch of components you will need to think about in the future (whether you stick with Firebase or not), and the key here, is that there are tons of articles, youtube videos, and other courses you can take to pick it up pretty quickly. You could even clone an Instagram knockoff from github. Guess what else, it's all free. You might not need to worry as much about the backend since there are client libraries for Flutter/Dart for Firebase.

Some might have different opinions, and like I said, I'm usually agnostic, but in this case, you have a lot to consider. Where are you going to store the data? Are people going to need to login? Will there but customized settings the will save even if I close the app? Yeah, that's just a few questions.

Those are just a few. Lots to consider, so if you want to get something in your hand as soon as possible, try a search for flutter + firebase + chat + Instagram or something like that and have a look.

If this is for learning about how to design the system, then pick the tools are you are confortable with.

Often times, I get stuck picking the tools (and trying to learn about them) vs actually trying to design the system itself.

If you are familiar with React (check out Expo) and Django then I would recommend going with that.

For deploying your backend, I would go with a provider like https://zeit.co/ that automates a whole bunch of deployment steps with their cli tools that you might have to do with AWS.

The above listed tools will do the job, you just need to figure out your architecture(e.g models). How they will all connect. Then you can use a tool you are comfortable with to implement them.

What you need to take a look at is Apache OpenMeetings. It already does what you want, it is open source and well documented and only requires that you design the UI and plumbing required to serve you application.

Let's select right tool you feel you are good at. And selecting tools are used by large community to solve your stuck if encounter

I've worked with all three of these languages and also with Java developers converting to these languages and far and away Go is the easier one to convert to. With the improved cold-start times and the ease of conversion for a Java developer, it is a no-brainer for me.

The hardest part of the conversion though is going to be the lack of traditional Classes so you have to be mindful of that, but Go Structs and interfaces tend to make up for what is lost there.

Full Disclosure: I'm a 95% Go convert (from Python) at this point in time.

Although I am primarily a Javascript developer myself, I used Go to build AWS lambda in a similar scenario to yours. AWS libraries felt better integrated on the Go side, I believe due to the language itself (e.g. how JSON objects are handled in go). Besides that performance of Go is much superior. But on the cons side; community is far smaller around Go, compared to Javascript. That is easy notice if you look at repos of community-maintained libraries for Go. That can feel a bit unreliable.

Go would provide the easiest transition for Java programmers -- its IDE/tooling is second to none (just install Goland) and the deploy/distribution story is extremely clean and lends itself to work well in lambda: single, static binaries with quick startup. No need to set up a full environment or package dependencies on your lambda AMIs, just copy a file.

If you want to prioritise language familiarity, JavaScript is more like Java than the other choices; and it can be optimised to run very fast. However if you need really fast cold-start times, you can't beat Go since it's compiled. There are other things to consider, such as the massive amount of community packages and help/documentation in the JavaScript ecosystem. Go is newer but seems to be quite popular if you need something that runs fast in a single binary.

I was initially going to suggest JavaScript due to the smaller size needs of AWS Lambdas code and the larger range of libraries and community available (and to avoid Python for this). But I have to agree with the recommendations and rationale of @ayildirim above and I think you should choose any reasonable language that is low-overhead, fast startup, and best supported by AWS Lambda, and that is probably Go. I don't think you are likely to go wrong with that, while you can potentially with the others.

So I'd agree, on the strength of AWS Lambda support and the solid performance of Go, it seems like your best choice here for Lambdas (and I'm going to need to consider that myself going forward... pardon the pun).

I've picked Node.js here but honestly it's a toss up between that and Go around this. It really depends on your background and skillset around "get something going fast" for one of these languages. Based on not knowing that I've suggested Node because it can be easier to prototype quickly and built right is performant enough. The scaffolding provided around Node.js services (Koa, Restify, NestJS) means you can get up and running pretty easily. It's important to note that the tooling surrounding this is good also, such as tracing, metrics et al (important when you're building production ready services).

You'll get more scalability and perf from go, but balancing them out I would say that you'll get pretty far with a well built Node.JS service (our entire site with over 1.5k requests/m scales easily and holds it's own with 4 pods in production.

Without knowing the scale you are building for and the systems you are using around it it's hard to say for certain this is the right route.