The Future of Python, Ruby, Go, and C#: 4 Key Trends from an Expert

Contents:

• Disadvantages of C# and Go: A Look at the Languages ​​from Microsoft and Google
• Comparison of Python and Rust: Key Aspects of Popularity and Functionality
• Ruby — Prospects and Challenges of the IT Market

The Disadvantages of C# and Go: A Look at the Languages ​​from Microsoft and Google

You recently expressed your critical position on the C# and Go programming languages ​​on Twitter. What are the reasons for your criticism, and what exactly don't you like about these languages?

Although my profile may seem strict, it's just a joke. In fact, I'm not that categorical—there's a grain of truth in every joke.

C# was my first serious programming language in the professional sphere. All previous attempts to master programming were merely school hobbies. I began my career as a programmer with C#, and this language opened up the world of software development and the opportunities it offers.

My choice of programming language was dictated by the needs of the labor market in Ufa. In the mid-2010s, our city's IT sector was in its infancy, and C# became popular thanks to the active use of Microsoft products in the public sector. When looking for a job, C# seemed the most attractive and promising option. I mastered this language and joined Transneft, where I worked for two years, gaining valuable experience in software development.

My criticism of C# is not related to the language itself, but to the technology stack that a developer must master. I am not a fan of Microsoft and dislike languages ​​that require excessive "ceremony" and boilerplate. I wanted to focus on functionality, so at some point, I realized that C# did not meet my requirements. However, the language itself has its merits, and ultimately, I chose Go as a more suitable one for my needs.

Our reasons for switching to the Go programming language were similar to the generally accepted ones, but we also had our own unique factors. We were looking for a language that would provide high performance, ease of use, and scalability. Go offers efficient tools for developing multithreaded applications and a simple syntactic structure, making it a suitable choice for our needs. Importantly, the Go community is actively growing, allowing us to receive support and access to modern libraries. All of these aspects were key in my decision to switch to Go.

The situation with the Go programming language is somewhat different. In rare cases, it conflicts with my principles of good programming. Despite the presence of multithreading primitives, which I highly value, Go generally lacks consistency. This aspect can impact the development of complex systems where clear structure and predictable code behavior are important. It is important to understand that the choice of programming language always depends on the specific tasks and preferences of the developer.

Let's consider Python. This programming language has a clear paradigm and philosophy, which contributes to its harmonious development. New features and capabilities are introduced naturally, in line with the core principles of the language. Python continues to evolve while remaining true to its essence, making it a popular choice among developers.

Unfortunately, I have not been able to discern a similar philosophy in the Go programming language. It is perceived as limited due to its primitive nature. If Go is designed for concurrent programming, why doesn't it include support for immutable data structures? This is a significant shortcoming that can limit developers and their ability to create more complex and efficient solutions.

I'm somewhat dissatisfied with slices in Go, as they store references to strings rather than copies of them. This can lead to unexpected side effects, especially when manipulating data. Additionally, some constructs in Go require more code than their Python counterparts. This can complicate the development process and make the code less readable.

So what about its vaunted readability?

Proponents of the Go programming language claim that the code is written in an easy-to-read format. However, this statement is not entirely true. While certain elements of the code are indeed easy to understand, the idea that managers can easily understand it is not true. The reality is that fully understanding code requires a certain level of knowledge and experience.

In this regard, Go is more like Java than Python. While some people believe that Go is a compiled version of Python, this is an exaggeration. When comparing code written in these two languages, you'll notice that Python is generally more readable.

I didn't stick with Go for long for various reasons. However, my experience with this language allowed me to expand my programming horizons and draw important conclusions. Go has opened up new approaches to development, which has significantly enriched my experience and understanding of various technologies.

Comparison of Python and Rust: Key Aspects of Popularity and Functionality

You often talk about Python. Is this programming language central to your professional life today?

My acquaintance with Python began at university, and since then it has become a true passion for me. At my previous job, where C# was predominant, I was one of the first to implement Python into work processes. I always considered myself a Pythonista, even when I was learning C#. Nowadays, remote work opens up new opportunities for programmers to participate in international projects, which was significantly more difficult a few years ago. Python continues to be a sought-after language, attracting the attention of developers due to its simplicity and versatility.

Did you return to learning Python during the pandemic?

I left C# before salaries started to increase significantly. During this period, I became more confident in interviews and was able to actively share my ideas. Although I had no formal experience with Python, I managed to get a job at a company in Ufa that was already using this programming language.

This wasn't just a return, but a significant milestone in my development as a Python developer. I've always considered myself a Pythonista, even when coding in Go and C#. My path to Python mastery was quite winding, but it became the foundation of my professional growth. Python continues to be my primary tool thanks to its simplicity and versatility, which allows me to effectively solve a variety of development tasks.

Python stands out for its simplicity and readability, making it an ideal language for beginning programmers. Its intuitive syntax allows you to focus on solving problems rather than learning complex rules. Furthermore, Python has a powerful standard library and supports many third-party packages, expanding its functionality and application in various fields, such as web development, data analysis, artificial intelligence, and automation.

The Python community is active and constantly growing, creating a rich ecosystem for sharing knowledge and resources. Thanks to the active development of the language and its libraries, Python remains relevant and in demand in the job market. This makes it an excellent choice for professionals seeking a career in IT.

It is also worth noting that Python supports programming paradigms such as object-oriented, functional, and procedural, making it a versatile tool for solving a variety of problems. All these qualities make Python not only powerful but also an accessible language appreciated by both beginners and experienced developers.

Python excels in its ability to efficiently and concisely transform ideas into code. Among widely used programming languages, Python is arguably the most expressive and accessible. What might take 20 lines in Go can be expressed in just one in Python, while remaining understandable and readable, rather than turning into complex regular expressions, as in Perl. The brevity of the code significantly facilitates its reading, which is a key aspect in the development process.

It is important to remember that “not every short code is easy to read, but all readable code is short.” This significantly reduces the number of errors, makes the code more reliable and speeds up the development process. When working with Python, I especially appreciate its versatility. I often tell my entrepreneurial friends: "Whenever you don't understand a situation, just add Python." This programming language allows you to quickly solve a variety of problems, which makes it an indispensable tool in modern business and development.

Python is highly versatile and can be used in a wide variety of areas. It can be considered "superglue" that connects various technologies, including languages ​​​​like C++. Although I am not a big fan of the C language, I believe that Rust copes with low-level tasks more efficiently. In this regard, I decided to use Rust in combination with Python and recommend other developers to consider this approach to improve productivity and optimize projects.

An interesting combination. Why the Rust programming language? Rust stands out for its safety, high performance and parallel processing. These characteristics make it an ideal choice for developing systems software, as well as for creating applications that require reliability and efficiency. Rust is also actively supported by the community and has a rich library ecosystem, which facilitates rapid and high-quality project development. Choosing Rust can significantly improve code quality and reduce the number of errors, which is especially important in modern software solutions.

Python is often called a glue language, as it allows for easy binding of various components and libraries. However, the efficiency of running Python code is often limited, since many of its modules and functions are implemented in the low-level C language. This means that the performance of Python programs can be lower than that of programs written in C. When developing custom solutions, one has to turn to C, which is associated with a number of difficulties, such as memory management and complex syntax. Therefore, I decided to explore alternative programming languages ​​that can offer higher productivity and ease of development.

I studied the D language, but its attempts to offer a clear and structured syntax did not live up to expectations. D turned out to be a language with automatic memory management, which is a significant drawback for systems programming languages. As a result, I began to explore Go and Rust, which offer more efficient solutions for developing systems software. Go appeals for its simplicity and high performance, while Rust stands out for its memory management safety and high execution speed. Both languages ​​have their advantages and are suitable for various tasks in the field of systems programming.

I am impressed by how Rust allows you to effectively solve low-level problems, such as developing network protocols, thanks to its powerful type system. While Python is great for high-level tasks and rapid prototyping, Rust provides the necessary tools for working with lower levels while ensuring safety and performance. Using Rust in such scenarios allows you to create reliable and optimized solutions.

Rust's type system is very similar to Haskell, which I studied due to my interest in functional programming. Rust offers powerful mechanisms for expressing various concepts, which significantly reduces the likelihood of errors in your code. This feature makes Rust particularly attractive to developers seeking to build robust and secure applications. Low-level type manipulation and strong typing avoid many common problems, leading to higher software quality. Many users continue to choose the C programming language for several reasons. First, C provides a high level of performance and allows for detailed management of computer resources. This language is widely used in systems programming, operating system development, and embedded systems. Second, C is simple and efficient, making it ideal for learning programming fundamentals. Many modern languages ​​were built on top of C, making it essential for understanding how other languages ​​work. Furthermore, a large developer community and the availability of numerous libraries and tools contribute to C's popularity. These factors make C a viable choice for many programmers. Rust offers unique concepts that distinguish it from other popular programming languages, including affine types. This feature allows for the ability to check that certain entities are used only once, which is especially useful in the context of working with files. Because of this, Rust promotes increased safety and prevents errors related to resource reuse.

While I'm not an expert in low-level programming, I do know how an operating system works. In most cases, Rust demonstrates advantages over C++ due to its safety and memory management. However, C++ has a significant number of existing tools and libraries, giving it certain competitive advantages. These factors make C++ an attractive choice for many developers, despite Rust's growing popularity in the programming community.

Rust has the potential to replace C in certain areas, but completely displacing it is unlikely. C has been used in systems programming and embedded systems for decades due to its simplicity and high performance. Rust offers advantages such as memory safety and race-free concurrency, making it attractive to developers. However, many existing projects and libraries are written in C, and migrating them to Rust can be difficult and expensive. Therefore, while Rust has the potential to gain significant market share, completely displacing C in the foreseeable future seems unlikely.

It depends on the specific context. In game development, using Rust can be challenging, but in areas such as driver, server, and protocol development, Rust actually has many advantages over C. It significantly reduces the likelihood of errors due to its strong type system and memory management, making it a safer choice for developers.

C is a low-level programming language, but working with it can lead to frequent memory management errors. Unlike C, Rust is also a low-level language, but thanks to its strict type system and memory management mechanisms, errors in Rust are less common than in languages ​​like Java or Python. However, using Rust requires developers to be highly skilled and have a deep understanding of its concepts, which, in turn, is one of the reasons for its relatively low popularity among programmers. Educational content on the Rust programming language is indeed scarce. However, resources like Rust Book are considered one of the best for learning this language. Despite the high quality of the materials, many beginning developers face difficulties adapting to Rust's strict compiler. It demands precision and does not tolerate even hypothetical errors, which can be unusual for beginners. To successfully master Rust, it's important to focus on hands-on learning and actively studying the documentation, which will help you overcome difficulties and master the language more quickly.

Rust is often humorously referred to as "compiler driver development." This is because if a program compiles successfully, it means it's correct. This approach ensures a high degree of code reliability and safety, making Rust a popular choice for systems programming and high-performance application development.

The compiler has many advantages that make it a particularly useful tool for developers. First, it converts source code into machine code, allowing programs to run faster and more efficiently. Second, the compiler helps identify syntactic and semantic errors at compile time, simplifying debugging and improving code quality. Furthermore, modern compilers often offer optimizations that improve application performance, reducing its resource consumption. Last but not least, compilers support various programming languages, which expands their applicability in various areas of software development.

Rust significantly simplifies compile-time processes, as it has no runtime. The language compiler is highly strict, which helps avoid many errors, including data races. For example, if two threads try to simultaneously access the same mutable object, the code simply will not compile. This ensures safety and stability when working with multithreading, making Rust an ideal choice for developing high-performance and reliable applications.

In the Rust programming language, many processes are managed at compile-time, which reduces the amount of routine work for developers. The Rust compiler is generally an advantage, as it ensures high code safety and performance. However, using the language effectively requires time to get used to the compiler's features and its strict requirements.

The error handling system in Rust is one of the key features of the language. Errors are returned as results, which encourages developers to check them. This helps avoid situations where exceptions go unhandled and promotes more reliable and secure code. This system allows developers to better manage errors and minimize the risks associated with incorrect program execution. Rust provides convenient tools for error handling, which makes it especially attractive for creating high-quality applications.

The Go and C# programming languages ​​have certain Features that Python and Rust may lack. Go offers simplicity and high performance, making it ideal for developing network applications and microservices. It also has built-in support for concurrency, making it easy to create multithreaded applications. C# stands out with its robust ecosystem and extensive library, making it suitable for developing complex enterprise applications and games on the Unity platform. Both languages ​​offer strong typing, which helps avoid compile-time errors. Unlike the more dynamic Python and Rust, Go and C# provide more predictable code behavior, which can be an advantage in large projects. The choice of programming language directly depends on the specific tasks that need to be solved. While Go has its advantages, for my purposes, Python and Rust are much more suitable tools. Python offers simplicity and a rich library ecosystem, making it ideal for rapid prototyping and web application development. Rust, on the other hand, provides high performance and security, making it an excellent choice for systems programming and the development of highly loaded applications. Thus, the choice of programming language should be based on the specifics of the project and its requirements.

Python has limitations in performance and multithreading. Despite the existence of mechanisms for multithreading, their implementation often makes it difficult to effectively use parallel threads. Paradoxically, the Go language offers a more effective embodiment of one of the core principles of Python's Zen: "There should be one, and preferably only one, obvious way to do it." This makes Go a preferable choice for tasks that require high performance and efficient thread management.

Currently, Python faces a problem of diverse approaches to problem solving, resulting in a lack of a unified standard. This situation is reminiscent of server-side JavaScript, where developers also face a variety of methods and practices. One reason for this may be the tendency of Python programmers to follow current concurrency trends without considering the consequences of their decisions. In contrast, the Go programming language offers a more standardized and understandable approach to development, making it the preferred choice for many developers.

Ruby, although lagging behind Python in concurrency and multithreading, is taking a more promising direction, which could open new horizons for its development. Technological advances and a vibrant community could contribute to Ruby's resurgence as a popular programming language.

Ruby — Prospects and Challenges of the IT Market

Ruby is once again attracting the attention of developers thanks to its unique features and high degree of abstraction. Although the language is not as popular as its competitors, its applications remain relevant. In a recent conversation with an expert studying Elixir and Ruby, I discussed his views on the future of Ruby and its place in the world of modern technology.

Why Ruby? I asked this question, and he explained that he was attracted by the high readability and conciseness of the code. He compared Ruby to Python, noting that while both languages ​​have their advantages, Ruby offers an even more convenient and cleaner syntax. This makes it an ideal choice for developers striving to create understandable and maintainable code. Ruby is also known for its robust ecosystem and active community, which further enhances its appeal to programmers.

Despite its advantages, Ruby does have certain drawbacks. One of the main drawbacks is performance, which is inferior to Python. Ruby also does not always handle multithreading and asynchrony efficiently. However, Ruby's high-level syntax makes it an excellent choice for rapid application development, which attracts many developers.

"Have you ever considered switching to Ruby completely?" I asked. "No, Python is still in demand. However, I see significant potential for Ruby, especially in the job market. Remote work has led to an increase in global demand for developers, and although Ruby is not as popular, there is still a shortage of specialists in this field. This creates opportunities for career growth and development, especially for those willing to delve deeper into this technology.

Ruby developers' salaries often exceed those of specialists working with Python and Java. This creates additional incentives for learning Ruby. It is interesting to note that Ruby accounts for approximately 6% of the web development market, which is significantly higher than Python (1.4%) and JavaScript (1.8%). Learning Ruby opens new career opportunities and increases the chances of landing a high-paying job in web development.

The success of the Ruby programming language is largely due to the popularity of the Shopify platform, which is rapidly gaining popularity among users. Shopify, based on the Ruby on Rails framework, has become one of the most sought-after content management systems (CMS) in the world. This opens new prospects for Ruby developers and creates opportunities for creating efficient and high-performance web applications. With the growing interest in e-commerce, knowledge of Ruby and its ecosystem is becoming an important asset for professionals in this field.

Ruby has not become mainstream for several reasons. Despite its advantages, the language syntax can be challenging for beginners. Ruby is not the easiest language to learn, and mastering it often requires significant time and effort. This can be a deterrent to novice developers seeking more accessible and intuitive programming languages. Thus, while Ruby offers powerful tools and capabilities, its complexity may limit its popularity among a wider audience. Ruby attracts experienced developers because it requires a deliberate approach to learning and using it. As a result, Rubyists are often perceived as the power brokers of the IT industry. Given the growing interest in Ruby, it is likely to assume a more significant position in the programming market in the future. Every year, more and more professionals are learning Ruby, recognizing its advantages in developing web applications and systems. How to effectively manage multiple programming languages? Learning new languages ​​promotes logical thinking and opens new horizons in a programming career. This is especially relevant for mid- and senior developers, as the diversity of technologies helps prevent professional burnout and maintains interest in the work. By mastering new languages, programmers can improve their skills, adapt to different projects, and increase their competitiveness in the job market.

• Develops creative thinking;
• Expands professional horizons;
• Helps adapt to new market demands.

Maintaining knowledge of all programming languages ​​simultaneously is difficult. Therefore, it is critical to confidently master your primary technology stack. This will allow you to better understand the specifics of working with your chosen language and solve problems effectively. In-depth knowledge of the primary stack will help not only in development but also in process optimization, increasing overall productivity.

Which programming language should beginners learn? In response to this question, the advice was given to start with Python or JavaScript. These languages ​​are popular due to the abundance of educational resources and high demand in the job market. For experienced developers, especially those who already know Python, learning Ruby can open new horizons and opportunities for career growth.

Check out additional resources:

• Why has Go become so popular and how much do developers earn?
• How to move from a junior to a mid-level developer?
• How is Rust different from C++: a veteran programmer's opinion?