How can you mitigate the risks of using an unfamiliar programming language?

It is not just about building the software. Need to consider the maintenance also. Need to consider the talent availability in the market on the new language. Need to consider the industry/community support to build capabilities/libraries around that.

Every programming language shares similar foundations, one should be clear about the basics of programming like OOPs concepts and computer fundamentals, rest will come with practice. Using new programming languages for different projects is like playing a mind game for up skilling oneself. It's important to know about the limitations of the language and understand its compatibility with the project requirement. For example - if my project demands a lot of concurrent programming I might go for kotlin or Java, which has a huge community support online in case I get stuck at some errors. When going with a new programming language it's important to ensure that resources are easily available via community support.

This is a bad way to reason. First problem : there are two issues in one here, 1) What are the risks ? 2) For each risk, how to mitigate it ? We should first agree on the risks, before contemplating mitigations. Second (bigger) problem : _never_ separate risks from benefits. It's always a balance, you cannot reason on risk without knowing why you're running it. (hint: because some greater benefit is expected)

When you're faced with a new programming language, it's like starting a new game. Start by thoroughly understanding the language, and considering its suitability for your project. Begin with simpler tasks to build your confidence, seek guidance from experienced developers, rigorously test your code, maintain comprehensive documentation, and continually assess potential risks. Think of it as embarking on a journey where learning and adaptation are key. If obstacles become overwhelming, ensure you have a backup plan to return to a familiar language, much like having a safety net in place.

You should always start from a simple project, with enough complexity to show you what you need to know, without going too deep. In the meantime, you should start taking a look at ways to make your code more testable and then, you should read some articles or books about the best design for this particular language.

A good code editor is akin to a craftsman's toolkit. It not only makes the coding process smoother but also helps you maintain a higher level of code quality. Code editors with syntax highlighting and autocompletion can greatly reduce typographical errors and make code more readable. Debugging tools integrated into editors can save hours of troubleshooting. Furthermore, the choice of a code editor can impact your productivity significantly. It's essential to select one that aligns with your workflow and supports the language you're using.

Code Editor or IDE that support the language is a great way to get into the new language initially. But as you progress with the language, the features provided by such software becomes trivial. One thing to consider when choosing one, is if you are in a company or is this a personal project. If it is the former, then select a code editor or IDE which is used by the organization. This way, you could get help when needed almost immediately and provides consistency when writing code.

To select the code editor, I have to learn the team member's experience. I have to select that editor, which is voted by developers. Because, each editor has some positive and negative sides. So, I have to emphasize on developer's preference.

- Assert that development tools (editors, compiler, resource manager, package managers etc..) and documentation are readily available.

Coding standards act as a common language for developers working on the same project, ensuring consistency and maintainability. When working with a new language, it's tempting to adopt your existing coding habits, but adhering to the language-specific standards is crucial. These standards often encapsulate best practices, naming conventions, and formatting guidelines that the language's community has agreed upon. By following them, you not only make your code more understandable to others but also position yourself to take full advantage of the language's features.

Maintaining the coding standard is mandatory for large scale project. Team lead will confirm that each developer is following the coding standard and organizational preferences of coding. If team lead failed to maintain the standard, then the project will not sustain. Because, new developers cannot be able to update the code if current developer resigns.

Learn the Language-Specific Standards Use Code Analysis Tools Follow Naming Conventions Indentation and Formatting Commenting and Documentation Modularize Code Consistency in Code Structure Error Handling and Exception Handling Automate Checks

Power of clean code will be know when a new person in team is trying to understand what we wrote in past. Coding is not just about building features it also needs to maintained. To achieve that clean and understandable code is needed. Some points need to noted as as follows: -Code docs like javadocs need to added, this really reduces boilerplate code when such similar functionality is already implemented. -Informative naming conventions for methods and variables etc., this minimizes complexity when some new person tries to go over code. -Smart use of conditions. -Installing IDE plugins like sonar lint. -Trade offs need to be weighed before using new features provided by any language (Ex: AWS announced to not use web services everywhere)

Leveraging libraries and frameworks can significantly expedite development and enhance the stability of your project. When dealing with an unfamiliar language, this becomes even more important. These resources are created and maintained by experts in the field and have often been battle-tested, reducing the chances of introducing subtle errors. However, it's essential to choose libraries and frameworks that are well-documented, actively maintained, and compatible with your project's goals. Additionally, using wrappers to access libraries from other languages can expand your toolkit and integrate existing solutions seamlessly.

Frameworks are the real challenge/opportunity. After enough experience, a new language is not usually hard to pick up. New frameworks usually need time, and selecting the right one also takes time.

One crucial point to remember about libraries and frameworks is that they are not the language itself. While they can certainly streamline the development process and simplify language usage, it's essential to comprehend what lies beneath them. Most libraries and frameworks make our work easier by implementing language specifications in a user-friendly manner. However, this doesn't necessarily mean you fully understand the language. If you aim to learn an unfamiliar language, you should delve into its specifications and how libraries and frameworks incorporate them.

Testing and debugging are not just good practices; they are lifelines in software development, especially when working with a new language. Writing comprehensive unit tests, integration tests, and system tests can help you identify issues early in the development process. Debugging tools and profilers are your allies when trying to understand and fix runtime errors and performance bottlenecks. Embrace a test-driven development (TDD) approach when possible, as it can help you gain confidence in your code and catch issues before they become critical.

Code reviews are an essential tool when introducing and new programming language. They allow to share knowledge. Assert, that the code can be managed using standard version management tools. Assert that the compiler properly integrates in CI/CD processes.

Many individuals believe that code testing primarily involves the search for bugs. However, it's important to recognize that testing encompasses more than just bug identification. In fact, it also involves evaluating the user interface (UI) because even if your program is entirely free of bugs, it can still be rendered practically unusable due to a poorly designed interface. To ensure the functionality and usability of your software, it is crucial to engage with your testers and seek their input.

I find that learning how to write unit tests is one of the best things to tackle first. Not only is it useful when doing development, but they are usually a good way to try out new language features/syntax/libraries, without having to build a whole app.

Never be afraid to ask a Senior Engineer for help or just for general pointers. They can help by teaching you the things that initially troubled them, pointing to good documentation sources, or just by giving general pointers. I've seen too many newer Junior developers fall behind on projects just because they were too stuck and afraid to ask for support.

- Assert that the targeted language is not too remote to what the team is currently familiar with. One does not go from C# to LISP or PROLOG “just like that”. - Assert that development tools (editors, compiler, resource manager, package managers etc..) and documentation are readily available. - Assert that there is a consequent developer community for the chosen programming language. - Organize recurrent engineering meetings about technical difficulties and their solutions.

Document, document, document. Your entry-level talent will be able to get productive much more quickly if the code is commented fully. Your code needs comments. No, it is not clear enough to make comments unnecessary. The people who say otherwise are wrong. Use comments to explain what the code is supposed to be doing at each point. Everyone who says that this is obvious is someone who is already familiar with the code base. Your new hire is not. Furthermore, because software development is a field of continuous learning, it is a field of continuous teaching. Comments teach your new people how things get done. In eleven years in industry, I have never been blocked because of unnecessary comments. Comments never hurt.

There is one thing that will always work. The KISS principle (Keep It Simple, Stupid). As you long as what you're trying to do stays simple enough, the language shouldn't be a problem. If you see that you're doing something very specific that requires you to go deep or even hack the language (or framework) in question, there are 2 possibilities: 1. You should take a step back and question your initial design, how would you do that in a language with which you are familiar with ? 2. It's really something that requires you to master the language or framework you're using and it can't be done in another way. In this case, you should try to find someone who can help you in your organization or/and online.

In my opinion, official documentation is the place to start. Understand the functionality properly and then try to implement a small POC so that you understand how it works. Asking someone who already has experience about the same is also something you can do.

Documentation is over rated. Notes written are not clear to anyone except to the author Documentation is never reviewed nor corrected Documentation is quickly out of date when coding under threat of deadline Documenting complex applications is impossible All multithreaded applications are complex Clear concise coding No gimmicks nor hacks Handle exceptions cleanly.. database connection times out.. what to do? Cloudflare disrupts your brilliant design? Works well with a few users but does it scale up? Code reviews. If you can’t explain the code in relatively few words.. rethink the design Real debugging ie not use faux test cases that are too simplistic

Strong core knowledge 1- always have a good understanding of what you’re doing/implementing disregarding the programing language 2- documentation is your best buddy 3- know the options, perks and limitations of the new language 4- know the conventions and best practices 5- seek mentorship, use forums and ask questions, its okay to explore and not know everything