What are the most common mistakes developers make when choosing a programming language?

Following the hype really limits your organization's ability to develop subject matter experts. Developers are struggling with learning curves instead of building a strong foundation, and building robust testing on top that. In all my years of experience, it's obvious that bad engineering and poor programing can be done in any language. A culture of engineering discipline is technology agnostic.

Overthinking about the language selection. In my opinion, for most of the projects, the language selection isn't that important. We just need to select a language that the team is comfortable with, and that satisfies our minimum requirements.

Always trying a new language or going with the perfect language that could solve each problem becomes a maintenance nightmare. Try to keep your stack mostly consistent to allow your team to switch between projects easily without having the heavy lifting of context-switching or learning an entirely new language

When selecting a language for your application, consider the importance of community support. Opting for a language with a strong community backing ensures easier access to solutions and support for your queries. Don't overlook the power of a helpful community!

Certainly, I will choose the slowest framework that I can get support from millions of other Developers than the fastest framework that only a handful of people understand.

There can be many new languages with many new improved functions but that does not outshine the need for a good community support for a particular code base. One does not have the grasp of all the ways a particular problem can be solved. Community can help in that scenario.

Chose the ecosystem where you can go from concept to MVP the fastest. For me that was Ruby on Rails. Every year people talk about how the latest framework is going to change everything but "boring frameworks" continue to support millions of businesses, ignore the benchmarks search basic questions and see how much support there is.

Not understanding the proper requirements for the software and then not doing proper analysis of technology they could use , for example in theory you can make an operating system in JavaScript but should you?

Most definitely! I think this is also directly related to following the hype train. When a technology is trending, developers tend to look at it with rose glasses and that everything is perfect. A smart developer always analyzes the tradeoffs of a language in an unbiased manner. Then tries to draw different scenarios where this technology would shine, as well as, scenarios where it might be a nightmare.

Coding is like making food: There's a difference between mindfully preparing a dish and just smashing two pieces of toast together and call it a meal. I always thought PHP was a very easy programming language to get stuff done, but the more I learned from Clean coding standards and performance improvements the more I realized how much there is still to be learned. Bottomline when choosing a programming language: check its potential in all areas, like checking the nutritional table at the back of the food you buy, and make sure to prepare for balancing its trade-offs. That way you'll get the most nourishment for your projects :)

Overlooking trade-offs in decision-making is a prevalent mistake, particularly in technology. For instance, choosing a database for speed might sacrifice scalability. Prioritizing a user-friendly interface might limit customization options. Each decision involves a give-and-take scenario. Recognizing these trade-offs ensures a nuanced approach. For instance, selecting a robust but complex framework may lead to longer development times

Understanding the trade-offs is crucial. Another common mistake is not aligning the chosen programming language with the specific requirements of the project. Each language has its strengths and weaknesses, and selecting one without considering how well it fits the project's needs can lead to suboptimal results. It's essential to assess factors like the nature of the application, performance requirements, scalability expectations, and the development team's expertise to make an informed decision that aligns with the project's goals.

Take the time to weigh the pros and cons of a few different languages for your particular use case to determine the best fit. Key factors would include: - Performance and stability - Readability - Available testing frameworks - Supported libraries - Licensing - Ease of debugging - Platform support - Documentation - Learning curve (especially for relatively new languages)

According to business conditions and technical complexities, each project may be developed better and cheaper in one programming language vs another one. Therefore, it is better to identify the different needs of the project well before using only the language they master. However, in my opinion, doing this work is in the higher layers of decision-making and the programmer does not make such a decision alone.

Common Lisp, being a powerful multi-paradigm programmable programming language that can easily and seamlessly absorb almost any programming language feature or paradigm as just a library, almost entirely nullifies the traditional limitations of sticking to one programming language, since different parts of the codebase can use different approaches perfectly adapted to the problem at hand. Common Lisp has traditionally been used predominantly on the back end, since any programming language can easily be used as long as it integrates with the appropriate standard protocols and formats, but the rise of WASM and its quickly improving support for highly dynamic languages is poised to soon open the door to Common Lisp on the front end also.

One language can't be a jack-of-all-trades. Enforcing the use of a language unsuitable for your application might stunt its growth. The best approach is employing multiple languages based on their strengths for a well-rounded system development.

While mastering one programming language is commendable, exclusively sticking to it can be limiting in the dynamic field of web development. Different languages offer unique features and solutions for diverse problems. By confining oneself to a single language, there's a risk of restricting creativity, productivity, and missing out on opportunities. Embracing the learning of various languages allows developers to choose the most fitting language for specific tasks, fostering adaptability and a more holistic problem-solving approach. In the ever-evolving realm of web development, openness to multiple languages enhances versatility, making developers more effective in addressing a range of challenges.

I don't understand why such extremes are always being discussed. Right, sticking to a single one is not good. But you also see a lot of developers jumping on the bandwagon of every new language. You should choose one language for one purpose/technology, e.g. web development, and master that one. Knowing a lot of languages but not mastering them hinders productivity. A good developer is not someone who knows a lot of programming languages; good developers are experienced ones who master the languages and tools they use. No company likes to be forced to manage a zoo of languages and tools. Get into a small bunch of languages and master them, but don't become one those using a lot of languages but not really knowing/masting all.

Ignoring testing across various browsers/platforms can lead to a subpar user experience. Ensure your code is optimized for all to guarantee a seamless performance for all users. Each language has its own testing tools and methods so always check it.

The only way to be sure your code does what's intended is by testing it. Testing libraries vary widely by programming language and some are better supported than others. There may even be restrictions on which frameworks you are allowed to use, as determined by your company. Many developers write their test cases to fit the actual behaviour of their code, which only puts focus on making the tests pass, but does not guarantee all the necessary scenarios are handled. By writing your code according to your test cases, you put more focus on making the code fit the expectations, not the other way around. If possible, highly recommend usage of tools like SonarQube to enforce quality metrics (e.g. test coverage, security) on all new code.

Writing code without testing it first (writing unit and integration tests) is costly for business. Accordingly, this is an important part of a developer’s life.

We cannot over estimate importance and benefits of testing of code during development before submitting it for quality assurance. It helps developers to discover leakages in the application (earlier) while developing and resolve the issue(s) before going far. It also reduces back and forth that normally occur between developers and Quality Assurance team.

Of course, overcoming challenges on your own is crucial to self-development because it builds confidence and discipline. However, learning from others is by far the fastest way to improve as a developer. Especially when it comes to versions of popular packages/languages that have been around for a couple of years, it is almost a given that someone has encountered your problem before. Asking for help doesn't mean you are lazy, it’s acting smart.

People are far less responsive to information others uncover than they are to equally relevant information they discover themselves, which is evidence of a major barrier to social learning. In a series of paid laboratory tests, after participants draw balls with replacement, we ask them to estimate the color composition of the balls in an urn. When a player draws themself as opposed to one made by another, participants' guesses are far less susceptible to that draw. This is true when the experimenter accurately communicates the signals of others, when participants have to learn the signs through conversation, and even when participants witness their teammate drawing balls from the urn with their own eyes.

Some developer might consider asking for help as a shame. They think that it lowers their reputation and that the others could understand those questions as a lack of professionalism. So it's very important to communicate to teams that exchange of knowledge does upgrade not degrade the quality of work.

When I started, I had the opportunity to work closely with another programmer who had over 30 years of experience, and even though he worked in a different language than my chosen one, I learned a lot from him! Programming is much more than just writing code, and experienced programmers have a lot to teach beginners in this regard!

Consider learning from other as an opportunity because you not only learning as per his/her knowledge on the subject but also from experience. In whatever industry you are, search for a good mentor. You can listen you well :)

Underestimating the importance of community support and documentation is also a mistake in my opinion. A language with a strong community can provide valuable resources, libraries, and solutions to common issues. Lack of support can hinder development progress.

Always beware of the herd mentality. The languages and their importance in the tech industry keeps changing every now and then. Do not fixate on one language. Yes being passionate about a particular language/tech stack is important but there is a fine line between the two. Always be open to accepting new challenges and ride the leaning curve ?

In short, a deep understanding of the requirements, a well-designed project management structure, a good team, and great communication are musts.

Consider the domain: It depends on which domain one is going to work in. 1. ML: Python 2. Banking and Finance: Probably Java 3. Trading: C or Go It also depends upon what we are trying to solve and what platforms we are going to target. It's helps to conform to the domain to get the support required.

learning logics are important, you can choose any language and learn the logics and the concepts of programming, and then you can switch between any programming language, it won’t be more hustle , mostly syntax and the execution of code differs and sometimes few concepts too. so someone shouldn’t bother about which programming language to choose instead focus of logics and concepts and if you know your requirements then it would be easier to start with one programming language for example :- for web development:- JS is must for AI and ML :- python is must