Contents:

How to quickly make money in IT in 2025 Try yourself in different areas of IT and take the first step to a new profession remotely!
Find out more
A developer at Tochka with migrant work experience. His primary technologies are Java and Python. He specializes in backend development. He has publications on the Habr platform. He is actively involved in migrating services from Java to Kotlin, which improves performance and simplifies code.
- How and why a programmer should switch to Python
- How to convince architects, the team, and the business to include a new technology in the stack
- Why Python's low speed is not a problem
- Why corporations choose Java and C#
- How Python became popular
- How to learn Python and switch from version to version
I started my journey in IT with a deep interest in technology and programming. Initially, I studied the fundamentals of computer science and programming, which led me to the Python language. I chose Python due to its simplicity and readability, as well as its wide range of applications - from web development to data analysis and machine learning. Python has become my primary tool because it allows me to quickly implement ideas and effectively solve complex problems. I'm also drawn to the active developer community, which promotes the exchange of knowledge and experience. With each project, I deepened my skills and expanded my horizons, which makes working in IT exciting and dynamic.
I've been programming in Python for five years. Previously, I worked with Java for five years. The switch to Python was driven by a desire for greater project flexibility and the use of microservice architecture principles. Python allows for faster development and implementation of solutions, which significantly simplifies working on complex projects.
When I decided to delve deeper into Python development, I was assigned a large monolithic Java project for revision, a boxed solution from a vendor that had already discontinued support. I had to create several new modules, but some of them turned out to be impossible to implement due to the need to integrate with other modules and programs.
To increase development speed and reduce the complexity of the existing monolith with an extensive code legacy, I started creating new services in Python. This will improve the flexibility of the system and simplify further work on the project.
This article is based on the podcast "People and Code," in particular the episode "He's Not a Rooster: Why the Enterprise Can't Do Without Python and What's Wrong with Java and C#." This episode discusses the key reasons for the popularity of the Python programming language in enterprise solutions. Python stands out for its ease of learning, a huge library of modules, and support for various programming paradigms, making it an ideal choice for developing complex applications.
Unlike Java and C#, which often require significant effort to write and maintain code, Python offers more concise and readable solutions. This is especially important for large projects, where development speed and code maintainability are critical. Python's use in areas such as data analysis, machine learning, and process automation also demonstrates its versatility and relevance in modern business solutions. Comparing Python to Java and C#, these languages have their advantages, but their complexity and more restrictive syntax can hinder rapid adaptation and implementation. Python, on the other hand, provides developers with flexibility and speed, which is especially important in the face of rapidly changing technologies and market demands. Thus, choosing a programming language for enterprise applications is not only a matter of preference but also a strategic move that can significantly impact the efficiency and success of a project. Python is becoming increasingly relevant in the enterprise, and its popularity continues to grow thanks to its ability to solve complex problems with minimal time and resources.
How and Why a Programmer Should Switch to Python
Choosing Python is indeed a serious decision, especially given the skepticism some programmers have about the language. But what exactly is causing such negative associations? Numerous memes about "rooster" and "golden-comb rooster" highlight various stereotypes and biases about Python. Some developers consider it too simple and suitable only for beginners, which causes dissatisfaction among more experienced programmers. However, Python continues to gain popularity due to its versatility, ease of learning, and wide range of applications in various fields, such as web development, data analysis, and machine learning.
Python's low entry barrier makes it accessible to a wide range of people, including schoolchildren familiar with frameworks such as Scratch. Many consider Python a simple language that makes it easy to see the results of their code. This contributes to its popularity among beginners, as Python development does not require in-depth programming knowledge. With its clear syntax and intuitive structure, Python is an ideal choice for learning the basics of programming and implementing simple projects.
Some developers like to claim that they are true programming professionals, having mastered static typing and C-style code. They pride themselves on their experience with languages such as C#, Java, and PHP and often criticize Python, considering it not a serious enough language. In their opinion, the lack of brackets and semicolons makes Python a less professional choice. In practice, however, Python demonstrates its efficiency and simplicity, making it popular among developers of all skill levels.
History repeats itself: several years ago, the PHP programming language caused considerable discontent among "true Java enthusiasts." Discussions became heated, and PHP was often criticized. However, over time, it became clear that this attitude toward the language was rooted in simple envy. While Java developers spent weeks working with JSPs, PHP programmers could quickly deploy a full-fledged backend and solve problems in just a few hours. Today, a similar situation is observed with Python. Despite its recognized promise and high efficiency in solving certain problems, it has also become an object of ridicule. It is important to understand that such disputes often arise from a lack of understanding of the capabilities of various programming languages and their application in real projects.

Python's dynamic typing is often criticized, especially by proponents of statically typed languages. Many discuss the shortcomings of running things at the runtime. Python is an interpreted language, meaning you need to install an interpreter to ensure cross-platform compatibility. However, interpreting code, as opposed to running compiled programs, can be less efficient. These shortcomings are often unfairly attributed to Python, when in fact the problem lies in the specifics of interpretation.
As a Java programmer, I was initially skeptical of Python. I sincerely believed that programming should be "proper": using classes and multi-level curly braces to make everything look rigorous and organized. However, after delving into Python, I realized that this language is much more readable in most cases. Python code is easier to understand, making it easier to understand and maintain.
I broke the traditional alcoholic rule that the alcohol should only get stronger as you drink. I decided to switch from the complex and prestigious Java programming language to the supposedly simpler and more popular Python. Did you ever feel like this was a step backwards? Did it feel like, as a musician, after Strauss and Schnittke, you started playing simpler and more commercial melodies?
Throughout my career, I've strived to simplify processes. I started working with C++, and at the time, many programmers didn't accept my decision to switch to Java. Later, when I chose Python, my colleagues working with Java also expressed dissatisfaction. Some of them still can't believe I was once their team lead.
I think that betting on the short end of the stick in programming is a perfectly acceptable approach. Indeed, there are more complex programming languages, and mastering the fundamentals of Computer Science requires a basic understanding of key concepts. Without this knowledge, switching from Python to Java can be challenging, especially in understanding how the Java Virtual Machine (JVM) works. It is important for beginning programmers to learn the basics to avoid problems later and ensure a smooth transition between different programming languages.
The world of technology is constantly evolving, and attachment to old approaches and hardcore methods is becoming unnecessary. Many professionals strive to maintain the image of their profession, and they are not always pleased to see how young developers, using modern tools, complete tasks much faster and easier than they did themselves. Others do not want to diminish the value of their work and the effort they put into learning a programming language. However, it is important to understand that adapting to new technologies can improve the efficiency and quality of work, as well as expand opportunities for creativity and innovation in the field of development.
When I switched from Java to Python, I had similar feelings. I felt like I was losing valuable experience, which is always perceived as painful. It's like leaving everything behind and starting over. Python is also generally less valued than Java in the job market, and I faced a salary cut of about thirty percent at the start. However, I knew it was a necessary move, and I don't regret my decision. Knowing my goals and striving for growth helped me overcome the transition challenges.
How quickly were you able to make up that 30%, if at all?
Within six months of my first performance review, I realized that the foundational knowledge and experience I gained in backend Java was a great fit for working with Python. Despite the stack change and the need to learn a new language from scratch, adapting to interpretation and dynamic typing was a challenge. It required significant effort and focus, but my fundamental programming knowledge made the process less daunting.
SQL remains the primary database language used by all backend developers. Networking technologies continue to run on Linux, and algorithms and data structures remain in their traditional form. Academic fundamentals, logical thinking, and set manipulation have not changed significantly in the past five years, and the protocols for interaction between systems have remained stable. However, the world and the market have changed significantly, and developers need to adapt to the new conditions. Ignoring these changes can lead to losing your competitive edge.
When I was developing a monolithic application in Java, I realized that I couldn't compete unless I started deploying small components in Python. The turning point occurred in 2015, when many companies began migrating to a microservices architecture. I was the first in my organization to try this approach. This caused a mixed reaction, and some architects were not enthusiastic about my ideas.
How to Convince Architects, the Team, and the Business to Incorporate New Technology into the Stack
Working in a team often involves the need for change, and this can create resistance. When you're quietly and calmly doing your job, the emergence of new ideas and suggestions can be perceived as a threat. It's important to understand that implementing change requires not only courage but also a strategic approach.
To successfully push your ideas forward, you need to establish open and constructive communication with stakeholders. Start by clearly and concisely explaining the benefits of the changes and how they will impact the overall outcome. Focus on the benefits for the entire team and the company as a whole.
It's also important to establish communication with the team. Try to create an atmosphere of trust where everyone can express their thoughts and concerns. This will help prevent your suggestions from being ignored and reduce the risk of conflict.
Use examples of successful change implementation on other projects to demonstrate the effectiveness of your ideas. Remember that constructive dialogue and a willingness to take others' opinions into account are key to successful change implementation.
Getting agreement with IT specialists is sometimes more difficult than with business representatives. If you approach the architect of a company focused exclusively on Java with a proposal to consider working with Python, you are likely to encounter many arguments explaining why this is not practical.
An architect who is already over 40 is inactive and resists change. If you think back to the situation five or six years ago, many technologies were banned. He asks the question: "Are you going to hire new staff? Where will I find employees who know Python?" This is a truly serious argument. The lack of qualified specialists capable of taking on a project, in the event of unforeseen circumstances, creates a significant risk for the business. A shortage of people capable of adapting to new technologies can be a serious obstacle to development and innovation within a company. Future-proofing projects is an important aspect that shouldn't be ignored. Almost every issue involves debates with technical specialists. These discussions can be complex and protracted, but they contribute to a deeper understanding of the project's needs. By analyzing proposals, you can determine whether they are truly necessary for successful implementation. Businesses are usually more receptive to new technologies and approaches. When you say, "Development in Java will take a week, but in Python, just two days," they begin to think and may even suggest launching a pilot project. This is especially true for responsible companies that aren't just trying to keep you busy, but are genuinely interested in achieving results. Openness to innovation and a willingness to experiment are key factors for successful interaction with business.

Business representatives are well aware of the benefits when they are shown how to reduce costs and speed up processes. It is important to note that the barrier to entry in this area is quite low, and there are a large number of Python specialists on the market. This allows you to quickly attract new employees and train them within your team, which makes the transition to Python an effective and cost-effective decision.
I launched a test microservice, demonstrating its functionality and speed of task execution. After that, all questions were removed. I prefer not to waste time on long explanations; it is much more effective to present code that independently performs tasks and demonstrates the results. This approach is the most convincing.
Why slow speed is not a problem for Python
Python is often criticized for its performance and execution speed, but this is not always a critical drawback. The main reason Python is considered slow is its interpreted nature and dynamic typing. However, many developers choose Python for its simplicity and ease of use, which allows for rapid application development and testing. For most tasks, such as web development, data analysis, and automation, execution speed is not a primary priority. Moreover, Python offers many libraries and tools that optimize performance, including the ability to integrate with faster languages such as C or C++. Ultimately, the choice of Python depends on the specific requirements of the project and the developer's priorities.
Java was previously criticized for the slowness of the JVM compared to C# in tasks requiring high CPU performance. Similar comments are now directed at Python. However, this is not the main problem. CPU-bound tasks, such as element counting, often do not reflect the real-world performance of the language. It is important to consider that the choice of programming language should be based on the specific needs of the project and its architecture, and not solely on execution speed metrics.
For complex computational tasks that require a high CPU load, Python can exhibit slow performance. However, it's worth considering: how many similar problems does a real business solve? In most cases, it's extremely rare. Exceptions are only in specific areas, such as search engines or complex computing platforms, where Python may be impractical. For most business applications, Python provides sufficient performance and ease of development, making it an ideal choice for solving everyday problems.
In other areas of business, SaaS microservices and similar architectures have long been implemented. There are companies that already have 200-300 microservices, and these are only Russian enterprises. One can only imagine the situation at giants like Netflix. Microservice architecture improves the scalability and flexibility of applications, which is becoming an important factor in the rapidly changing technology market.
Ecosystems primarily function thanks to the interaction of various subsystems. Key aspects include input-output mechanisms, protocol latency, and the rapid formation and sending of simple data. Support for idempotency and transactionality plays an important role, ensuring the reliability and stability of the entire system. These elements form the foundation upon which effective interaction within the ecosystem is built. Support for the concept of graceful degradation is an important aspect of modern web service architecture. This approach involves distributing tasks across different services and their asynchronous interaction. For example, when processing a payment in the system, if the transaction fails and the notification service is down, the payment service cannot immediately notify the user. In this situation, the task of sending a notification to the client is delegated asynchronously. Once the notification service is restored, it processes all accumulated tasks in the queue, using, for example, Kafka, and sends the necessary notifications. This approach ensures the reliability and resilience of the system, allowing users to receive up-to-date information even if individual components fail. Python is a programming language with over 30 years of history that has only come under criticism in recent years. Despite this, the Python community is constantly growing and developing, creating a variety of tools and libraries. Having a comprehensive toolchain significantly speeds up the development process and reduces the time required to train new developers. With the rising cost of programming specialists, effective tooling is becoming increasingly important for streamlining workflows and increasing productivity.
Strong developers create weak times, and weak times, in turn, create strong developers. This process is cyclical. Today, we are witnessing a turning point where attention is once again turning to static typing. Discussions are raising issues specific to the Python language. This is a relevant topic, as many developers are looking for ways to improve code quality and reliability. Static typing can be a solution for eliminating common errors and increasing development productivity.
Python can exhibit slow performance in CPU-bound tasks. However, its interpreted nature significantly simplifies the development process. There is no need to compile and rebuild the application each time. Changes can be made quickly, and restarting a Python server, even under high load, takes only a few seconds. This significantly simplifies the development process and ensures rapid application builds. In the context of microservices architecture and the application of twelve-factor-apps principles, such benefits become especially relevant and contribute to increased efficiency.
There's a meme in which a developer makes a mistake that causes each user to wait an extra second. This extra second, multiplied by the number of users, results in significant time losses. However, this approach to analysis is incomplete, as it is necessary to consider other important metrics, such as NPS (Net Promoter Score) and various factors influencing customer satisfaction. Proper analysis requires a holistic view of the user experience and its impact on the business.
We don't encounter errors randomly. In the event of brute-force attacks, we apply the graceful degradation principle mentioned earlier. For situations that require detailed analysis, such as complex network tasks, we can use parallel programming approaches. In this case, we add another interpreter that runs as a separate process on Linux, and it takes over the execution of tasks. This allows us to effectively distribute the load and ensure stable system operation.
We can use parallelism flexibly. In Python, starting with version 3.5, asynchronous programming has become a key element. This direction has led to significant changes in the community: developers began creating impressive frameworks and actively working with network applications. Why focus on languages that can complete tasks one millisecond faster when Python provides powerful tools for efficient asynchronous programming?
Why Corporations Choose Java and C#
Python is indeed a powerful and versatile programming language, but many companies continue to use languages such as Scala, Java, and C#. This is due to several factors. Firstly, Scala and Java have a long history in enterprise programming, making them reliable solutions for large projects. Secondly, these languages offer high performance and scalability, which is especially important for businesses with large volumes of data and high reliability requirements.
Furthermore, the market has a significant number of developers proficient in Java and C#, which facilitates the process of hiring and project support. Companies often choose a programming language based on existing technologies and the team's skills, which also influences the choice of language.
Thus, despite the advantages of Python, such as simplicity and code readability, other languages have their own strengths that make them preferable for certain tasks and projects.
I believe this phenomenon is a kind of vestige. Each company did not start developing its services from scratch – they were all based on programming languages that were popular at the time. In Russia, for example, C# still dominates in older companies, as universities previously trained specialists exclusively in this technology. This creates certain difficulties for the development and implementation of new solutions, as outdated languages and technologies can limit innovation and adaptation to modern market demands.
The Microsoft lobby remains active: computers equipped with Microsoft software can still be found in every laboratory at the Institute of Cybernetics. However, even back then, there were enthusiasts who, despite the prevalence of Windows, preferred to use Java and successfully accomplished their tasks. This demonstrates the diversity of approaches to programming and that the choice of operating system does not always determine success in this field.

Despite technological advances, experienced programmers continue to use traditional programming languages like C#. Moreover, there are specific tasks for which C# remains the optimal choice. For example, companies partnering with Microsoft and using Windows servers require their employees to know this language. In such cases, the job market favors specialists proficient in C#. However, the number of such cases where C# is the only option is decreasing every year.
Serious programming languages continue to be the foundation for developing large and complex systems. These languages typically represent monolithic solutions, where the concept of microservices has not yet become standard. However, there is a clear trend toward decomposing such monoliths, opening up new development opportunities. This indicates that languages such as C# and Java do not dominate the market, and competition between them and other technologies is becoming increasingly intense.
Cian has completely switched to Python, as demonstrated at their conference. Similar backend solutions in this programming language are being developed by companies such as Yandex, Sber, Tinkoff, and Mail.ru. Let's not forget my company, Tochka, which also actively uses Python to create efficient and scalable solutions. Python's use in large organizations confirms its popularity and reliability in developing modern web applications. Python has long carved out a unique niche in the programming world. It is a language not designed for creating complex backend systems that require significant computing resources and multiple servers. In contrast, Python offers ease of use, flexibility, and commercialization. Its application ranges from data processing and analytics to the development of graphical user interfaces. Although creating GUI applications in Python may be perceived as a less serious task, the language still demonstrates its versatility and effectiveness in various projects. Python is widely used in web development due to its simplicity and efficiency. Primary applications include lightweight backend development, online store and e-commerce systems, and work with various content management systems (CMS). Numerous ready-made solutions simplify development: simply connect the appropriate framework to get a full-fledged turnkey CRM system. This makes Python a popular choice among developers looking to quickly and efficiently deliver web projects.
There are numerous scripts designed for DevOps specialists and system administrators that significantly simplify various tasks. Using ready-made scripts allows you to avoid writing long and complex Bash code, which can be labor-intensive to maintain. Such tools help optimize workflows, increasing efficiency and reducing the time spent on routine tasks.
Data analytics using maps and redux now exists. Although it is not yet particularly fast, it is already being used. For example, Jupyter Notebook was developed for researchers and research institutes. It is a user-friendly interface that allows you to quickly perform microcalculations and write small code fragments. You simply write the code, and it is executed, which significantly simplifies the process of data analysis.
Bare Python in its pure form is rarely used, as in most cases there are knowledge bases, best practices, and specialized tools. However, Python is often used to develop service-oriented programming languages. These services can perform specific tasks, such as lambda functions, making them ideal for production use. This approach allows for efficient implementation of specific tasks and integration into larger systems, highlighting the versatility of Python in modern development.
How Python Became Popular
Python, despite being almost as old as Java, remained in the shadows for a long time. Java had firmly established itself on the backend and in the enterprise, while Python had been developing on the sidelines, attracting little attention. However, over the past ten years, a significant transformation has occurred: Python has gone from being an ugly duckling to a beautiful swan. The main reason for this change is not only the rise in popularity of Python, but also the decline in interest in languages such as C and Java. This is because Python offers a simpler and more convenient syntax, making it an ideal choice for beginner programmers and data scientists. Furthermore, the active development of Python libraries and frameworks, such as Django and Flask for web development, and NumPy and Pandas for data analysis, has contributed to its popularity. As a result, Python has become the language of choice for many developers and companies looking for effective solutions to modern problems.
The evolution of programming languages has been observed over the years. In the 1990s, the transition from Pascal to Java was quite simple: the differences in syntax were significant, but the basic programming principles remained the same. Python, like PHP, is an interpreted language, but PHP gained popularity somewhat earlier. This was due to its ability to solve many web development problems out of the box. While Python was primarily used as a scripting language, similar to Perl, it lacked the necessary tooling and tools. Furthermore, Python's philosophy differed from PHP's, which affected its usage.
The dramatic rise in popularity of Python 3 over Python 2.7 can be attributed to the significant changes that took place in the language. Unlike Java, where backward compatibility is an important aspect, Python 3 offered innovative features and improvements that made it more modern and developer-friendly. These changes allowed the language to adapt to new requirements and trends in programming, which attracted the attention of many programmers. Python 3 became a symbol of a new era in development, opening the door to a more efficient and flexible approach to software creation.
Python was originally developed as a scripting language, but over time, significant changes have occurred. Perhaps the key moment was Guido van Rossum's decision to rethink the language's concept. He decided to make a sharp transition to the third version of Python, taking into account community feedback and eliminating deprecated elements. This allowed the language not only to be updated but also to become more modern and convenient for developers.
The update had a positive impact on the perception of interpreted programming languages. By that time, JavaScript had already firmly established itself in the market, and PHP continued to be popular. Interpretation was no longer perceived as something negative. Python began to develop actively, accumulating tools, libraries, and frameworks, which contributed to its rapid growth and popularity among developers.
This was one of the few cases when a sharp transition had a significant impact on the development of technology. A similar change occurred with Sharp, which quickly adapted to .NET Core and as a result received tangible benefits. Such transformations show the importance of promptly responding to changes in technology to achieve a competitive advantage.
Sharpists are actively developing, focusing on a modern approach without trying to preserve the legacy of the past. They do not seek to fix the bugs of previous versions through backward compatibility, which distinguishes them from Java, which focuses on supporting its "three billion devices". Instead, Sharpists focus on implementing new technologies and solutions, allowing them to remain relevant in the rapidly changing world of software development.
The modern world of technology demands agility and speed in development. Many companies have realized that deep knowledge of all aspects of technology is not necessary. A mid-level skill level is sufficient to create an effective service. This opens up significant opportunities for businesses that value speed and error minimization. For example, instead of spending weeks fine-tuning a system with the help of an experienced Java developer, a mid-level Python developer can quickly integrate Django, package the project in Docker, and deliver a ready-to-use service. This allows teams to focus on developing business logic, significantly speeding up the process and increasing productivity. Thus, companies get access to high-quality solutions in the shortest possible time, which makes them more competitive in the market.

Python has several implementations, including CPython, Jython, and MicroPython. CPython is the standard version used by most developers. Jython allows Python code to run on the Java platform, enabling integration with Java libraries. MicroPython is designed to run on embedded devices and microcontrollers, making it ideal for developing IoT applications. These alternative Python implementations are needed to expand the language's capabilities and its application in various fields, such as web development, scientific computing, and automation. The popularity of each of these implementations varies depending on the needs of developers and the specific projects. For example, MicroPython is actively used in robotics and IoT projects due to its lightweight and simple nature.
Jython is extremely rare in production environments. Python developers, including those coming from Java, generally avoid using it. This is due to the language's peculiarities and limitations. Understanding the reasons for this caution will help you better navigate the choice of development technologies.
I've personally tried JIT compilation, which significantly speeds up code execution. We simply replaced the interpreter. Python has the ability to embed fragments of C code, which is an example of using a DSL. It is known that many Python libraries that require high performance are written in C. The GCC compiler is often required for their installation. This highlights the importance of integrating languages to achieve optimal program execution speed.
If fast builds or JIT compilation are not necessary, using a simple interpreter is a more convenient option. While using alternative build methods can be interesting from an academic perspective, it provides an opportunity to experiment and create unusual solutions. Using an interpreter simplifies the development process and allows you to focus on the logic of the code, without being distracted by the complexities associated with compilation.
This is not just a business story; this situation complicates projects and makes it difficult to hire developers, which negates the two main advantages that made Python popular. We must strive to simplify processes, increase collaboration between IT professionals and specialists from other fields, and create new capabilities and diverse products.
This is a clear example of the market situation that clearly demonstrates current trends. Recently, my engineering colleagues noted that I have begun to think more like a manager than a developer who is focused on small details. This statement is true: as an expert in my field, I understand the importance of achieving maximum results with minimal effort. Effective resource management and process optimization are becoming key to creating a significant impact in our field.
My choice of Python is due to its simplicity and conciseness. I prefer to write just a few lines of code rather than wasting time on long thoughts and complex constructs. Considering I already have Arch Linux installed, I do not need additional complexity. This philosophy reflects a desire for efficiency and minimalism in programming.
The Python philosophy, known as The Zen of Python, is truly impressive. Once you understand its principles, it will be difficult for a developer to write poor-quality code. Coding errors can lead to memory leaks or runtime crashes, making writing poor code virtually impossible. Everything in Python is very clear and binary, so compilation isn't even required upfront. This philosophy helps create more stable and efficient programs.
Test your knowledge of the Zen of Python and the philosophy of Lao Tzu by taking our quiz. This is a great opportunity to deepen your understanding of programming principles and the philosophical ideas that inspire developers. The quiz will help you evaluate your skills and expand your horizons.
When moving from C++ to Java and then to Python, the level of abstraction increases, significantly changing the requirements for a developer. In C++, a deep understanding of low-level concepts such as memory management and performance is essential, requiring careful code planning and optimization. Java, on the other hand, offers automatic memory management and stronger typing, allowing developers to focus on application architecture and interaction with objects, emphasizing OOP principles and design.
When working with Python, the emphasis shifts even more towards simplicity and code readability. Understanding development principles, such as maximum efficiency and the use of libraries, is paramount in this language, allowing for rapid problem-solving without the need to delve into low-level aspects. Therefore, a Python developer's focus is more on productivity and rapid prototyping compared to Java and C++, which require more attention to technical details and optimization.
Each of these programming languages requires a unique set of skills and approaches from the developer based on their specific features.
During my development in C# and Java, I paid significant attention to architecture and design patterns. My path began with design, after which I brought the created design into a working state. Using an object-oriented approach became the foundation of my work: I studied proper inheritance, creating the necessary abstractions, and implementing interfaces. This approach significantly improves the readability and maintainability of the code, and also ensures its flexibility and extensibility.
These factors complicated the code and increased the number of files in the project. The lack of best practices led to non-trivial problems. For example, the need to implement a facade in one place and pass a singleton for connecting to a database in another. It is important for the developer to think through such aspects, as they affect the quality and maintainability of the code.
Development is much easier in the Python ecosystem. I can create functions directly at runtime - in the Python Shell - and refactor them as needed. In this environment, modules from the project can be included in real time, which allows calling various code fragments and application functions without having to re-run. This allows you to instantly get working code with the necessary algorithms, which significantly speeds up the development and testing process.
You don't have to use Classmate to write code. You can get by with a single line, without coupling it with the language infrastructure. An example of this approach is Kotlin, where it is enough to declare a function and run it. This approach makes Kotlin more attractive to developers. JavaScript is also starting to develop in this direction, reflecting the trend toward simplifying code and improving the development experience.
Compatibility issues are a prominent issue when developing in Java. Difficulties often arise when using libraries not intended for your version of the language. If your version of Java is outdated, upgrading to a new one can be a real challenge, as unexpected dependency complexities always arise. This circumstance requires careful consideration when choosing libraries and upgrading the language version. Optimizing the development process and minimizing compatibility issues can significantly improve the efficiency of working with Java.
The C# programming language does not have the dependency issues typical of Java. In C#, dependency management is smoother, reducing the risk of serious problems. Unlike Java, where using Maven can lead to numerous problems if dependencies are not updated correctly, C# offers a more stable and well-thought-out ecosystem. This makes C# development more convenient and predictable, allowing developers to focus on creating high-quality code rather than resolving dependency issues.
Compiling large applications in Java can be challenging. Often, when starting the compilation process, developers get distracted by other tasks and then return, having forgotten about the changes they made. Furthermore, there is a risk of missing errors that only manifest at runtime, forcing a recompile. This highlights the need for effective development process management and careful control of code changes.
So those who try to explain to me that Python's disadvantage is its runtime are wrong. Because the runtime is everywhere. Runtime error is a common practice in both Sharp and Java.

In Python, I I can check the code and make sure it works, but there may be errors that a linter won't catch. This highlights the importance of writing tests to verify the functionality of the code and to keep track of variables when passing values between functions. Debugging in Java is significantly more difficult compared to Python. In Python, I can set a breakpoint in the code, run it in the terminal, and analyze the execution in real time, which allows me to quickly make changes and improve the code.
Most likely, this is a really effective technique. I often find that I lose concentration when I'm coding. I don't like spending a lot of time on design and analyzing the architecture. Python offers a modular approach that allows you to organize your code in a way that suits you. In addition, the language supports various programming paradigms: functional, procedural, and object-oriented programming. This gives you the opportunity to create a variety of abstractions and use the most appropriate methods for solving problems.
Python does not have strict rules regarding code structure, and using different approaches to organizing modules is acceptable. Having a class in one module and a set of functions in another doesn't cause a negative reaction among developers. This approach to code organization is considered normal and acceptable, allowing programmers to choose the work methods that are most convenient for them.
How to learn Python and migrate between versions
The programming language is constantly evolving, and many aspects of its updates remain a mystery to beginners. Programmers keep their skills up-to-date through various resources. Important tools include online courses, specialized forums, blogs, as well as documentation and developer communities. Keeping up with trends, they participate in conferences and webinars where they can learn about the latest changes and best practices. Regular practice and working on projects also help maintain their knowledge at the proper level.
Python has outstanding documentation that explains all aspects of the language in detail. Personally, I learned Python relying solely on official materials, without resorting to books, courses, or video tutorials. I simply opened the Python documentation and quickly figured out how to use the language effectively. This accessibility of information makes Python an ideal choice for developers looking to master the language on their own and without additional resources.
The book is written in a friendly and accessible style, making it easy to understand. It provides numerous examples that clearly demonstrate how to apply various concepts in practice. It effectively answers all the questions that developers may have, providing useful solutions and recommendations.
Java contains many legacy solutions and features that require a deep understanding of the language's source code. Without delving into its details, it is difficult to grasp the mechanisms of Java. This is an inevitable step for any developer striving to master the language at a high level. I myself have spent a huge amount of time studying these nuances to better understand how Java functions and how to effectively solve problems that arise.
Python documentation is high-quality and informative, providing users with up-to-date information on new features and updates. The transition between minor versions is usually smooth for developers. However, dependency issues can arise, such as with version 3.7, which introduced data classes that were missing in 3.6. However, if your project doesn't depend on other libraries, upgrading from Python 3.6 to 3.10 can be done without any code changes. This makes Python a convenient and powerful tool for developers, allowing you to easily update projects and take advantage of new language features.
I was recently talking to a Java developer, and he asked me, "Are you going to upgrade Python?" I said yes. I modified the Dockerfile, replacing "Python 3.6" with "Python 3.8." After that, I simply hit the deploy button, and the application was successfully deployed to the server. Upgrading Python turned out to be a simple and quick process, which significantly simplifies working with containers and improves the functionality of the application.
He asks, "What?! What's the matter?! Where's all the trouble?!" I reply, "The struggle will begin later, when I start upgrading some tools." Although problems with tool upgrades are rare, except when you're migrating from one major release of a large framework to another. However, that's a framework-specific issue, not a programming language-specific one. Upgrading from Python 2.7 to Python 3.0 is a significant challenge, as it's not just a version upgrade, but a transition to an entirely different language with a different philosophy and toolset. It's no surprise, then, that some developers express dissatisfaction, comparing their situation to migrating to Java. However, it's important to understand that Python 2.7 and Python 3.0 are fundamentally different languages, and that's an undeniable fact. The differences extend across all aspects, including interpreters, making migration even more challenging. Isn't this a factor that's scaring enterprises off? Large companies may look at the situation and think, "Well, there's going to be a sudden jump from version 3 to 4, so what do we do then?" Unlike Java, which maintains backward compatibility, in Python the community may decide that version 3 is obsolete and move to a new major version. This could result in the new version of the language being virtually different.
In the Java ecosystem, updating Spring can be a challenge due to incompatibility with the current version of Java. To update Spring, you must first update Java, which could cause difficulties for enterprises. This situation is similar to the possible release of a new version of Python that is significantly different from version 3. Such changes could cause similar problems for developers and organizations forced to adapt to new requirements.
It is unclear what plans the Python community and developers have for version 4. It is possible that there will be no version at all, or a rebranding is planned, in which a minor version will become version 4. Given the current situation, users are already ready to move to the new version of Python. Migrating from 2.7 to 3.0 turned out to be less difficult than many expected. There are numerous guides and an active community ready to help. There are developers who continue to maintain Jython, as well as those who create tools to automatically migrate projects from 2.7 to 3. I've tried such tools myself, and it was an interesting experience.
Python offers many libraries for various tasks, and there are indeed several solutions for working with them. These libraries allow developers to effectively solve a wide range of problems, from data analysis to web development. Thanks to an active community and constant updates, Python remains one of the most popular programming languages for solving a wide variety of problems.
Within the developer community, there is an important rule: you should not include a library to perform a simple function. Unlike JavaScript developers, who often add new libraries for each task, we always get the question at the review stage: "Why are you adding a new dependency?" The answer "That's how we do it" is not accepted. If a problem can be solved with a single line of code, then that is what you should do. This approach is consistent with Occam's razor, which I find very effective. This philosophy helps keep code clean and manageable, which is especially important during development.
Revised text:
Be sure to check out our collection of materials. Here you'll find relevant articles and useful resources on topics that interest you. We regularly update the content to provide you with the latest information and helpful tips. Don't miss the opportunity to deepen your knowledge and stay up to date with the latest news.
- Where to learn Python: 7 courses to master the language from scratch and get a job
- He's not a rooster: why an enterprise can't do without Python and what's wrong with Java and C#
- Kubernetes overview for programmers: how it's structured, how it works, and how it relates to clouds

