Preface
When I started my career in programming, it seemed like magic. Having stopped using visual programming in Construct 2, having switched to gdscript, my craft still seemed creative to me. I considered myself a creator, shaping whatever I wanted.
But over the years, this magic began to fade. Programming turned into a set of rules, patterns, paradigms, and endless libraries that, instead of expanding the possibilities, made me feel like a slave fulfilling other people's desires.
We forgot about why programming arose at all: to free us from routine, give freedom to desires, automate tedious processes and give preference to more important things, rather than focusing on what is better. Today we are stuck in an endless cycle of "while true", where marketing noise drowns out the voice of rational thinking, and the pursuit of "fashionable" technologies takes us further and further away from the true essence of programming.
This article is an attempt to awaken forgotten feelings in you, rethink what we do, and return programming to its original beauty. We will analyze the problems of modern programming, look for the causes of their occurrence, and perhaps find new ways to further develop this area.
Don't be afraid to ask questions, doubt, and argue - this is the only way we can avoid a "syntax error" that threatens to plunge programming into crisis and deprive it of its future.
Together we can make a difference, return programming to its true meaning and make the world a better place.
Chapter 1: Getting Rid of the Routine: The Early Years of Programming
The whole history of programming began long before the first computers appeared. In 1934, Alan Turing, the "father" of the modern computer, introduced his machine, which laid the foundations for the development of programming languages. His work became the key moment from which humanity's journey into the world of digital technologies began.
The first programming languages, such as Assembler, were perceived as a tool by scientists to help avoid manual writing of binary code. Programming was considered a temporary necessity, helping to transmit the necessary instructions to the computer.
An ideal example of a language that follows the original idea of "getting rid of routine" is C. Its minimalism and simplicity make it an ideal tool for solving problems. Learning C does not require significant time and effort, allowing the programmer to focus on developing algorithms.
In contrast to C, the Java language, following a different paradigm, is a cumbersome system with numerous functions, methods and libraries, making the learning process more difficult and time-consuming. Learning the language itself takes years, sidelining the development of algorithms, which is the main task of a programmer.
As a result, we see a paradoxical situation: a tool designed to simplify work becomes an independent problem. It's as if we use a heavy crane instead of a wrench, which makes tightening the bolts inconvenient and costly.
The art of programming is not to study the tool itself, but to use it to implement algorithms. A programmer, like a mechanic, should know how to "repair" programs, and not study a screwdriver as the main tool.
Instead of arguing about which paradigm is better, we should focus on solving specific problems using the tool that is most appropriate and convenient.
Chapter 2: The Evolution of Language: From Simplicity to Complexity
In the first chapter, we looked at how programming originated as a tool designed to save people from routine tasks. However, over time, programming has become more complex, intertwined with fashion, marketing and the pursuit of "new" technologies. This process has turned it into something more complex than originally thought.
In this chapter, we will dive into the evolution of programming languages, tracing how new abstractions and complications arose with each new iteration of languages. We will look at how the simplicity of the first languages, such as Assembler, turned into a complex system of modern languages.
From Assembler to C:
Assembler, the first programming language, was close to machine code. Programmers had to write instructions in the form of binary codes, which was extremely difficult and time-consuming. C, which appeared later, simplified the process by introducing a higher-level syntax that is easier to work with. C provided programmers with a more abstract level, allowing them to focus on algorithms rather than low-level details.
The emergence of object-oriented programming:
Object-oriented programming (OOP) has become a revolutionary step in the evolution of languages. Instead of a procedural approach, where the program was divided into a set of instructions, the OOP proposed the concept of objects that combine data and methods for processing them. This paradigm has made it possible to create more flexible and structured programs.
However, with the advent of OOP, the complexity of languages began. New concepts such as inheritance, polymorphism, and abstraction required the programmer to have a deep understanding of the principles of OOP, which made the development process more complex.
The emergence of "fashionable" languages:
With the advent of the Internet and mobile devices, the "race for novelty" began. New programming languages were constantly appearing, each with its own set of features and paradigms. This accelerated the process of language evolution, but at the same time made it less manageable.
Marketing and the "hype race":
Marketing has played a huge role in the development of "fashionable" languages. Often the advertising and hype around the language outweighed its real usefulness. This led to programmers switching from one language to another, chasing the latest "trend" without delving into the study of the languages themselves and their principles.
The result of evolution:
As a result of the evolution of languages, we have a world where there are hundreds of programming languages, each with its own characteristics and level of complexity. Programming has become more complex than in the early years of its existence.
In the following chapters, we will look at some of the problems that have arisen as a result of this evolution and try to understand how they affect modern programming.
Chapter 3: Programming as a Tool: From Creativity to Execution
In previous chapters, we have traced the evolution of programming languages, from simple tools to complex systems. But evolution has touched not only the language, but also the very essence of programming. Initially, programming was a creative process where the programmer acted as an artist creating new worlds and solutions. However, in the modern world, programming is often reduced to fulfilling orders, and the programmer becomes just a tool to achieve business goals.
From creativity to performance:
This shift from creativity to performance happened gradually. With the growing popularity of computers and the Internet, there has been a huge demand for programmers. As a result, programming has become a mass profession, and programmers have become "performers" who solve specific tasks on request.
Blurring the boundaries:
In the modern world, a programmer often loses contact with the end user. The programmer receives technical assignments from managers and developers, and his task is to implement these tasks in the form of code. Thus, programming turns into a "factory" where programmers perform routine tasks without thinking about the creative aspect of their work.
Example: Cryptocurrencies, neural networks, blockchain:
A vivid example of this phenomenon is the popularity of cryptocurrencies, neural networks and blockchain technologies. These technologies were presented as "revolutionary", promising a revolution in various fields. However, in most cases, they have turned into a marketing ploy used to attract investment and raise the share price.
Cryptocurrencies: Instead of becoming a new financial system, cryptocurrencies have become more the object of speculation, exacerbating problems with inflation and instability.
Neural networks: Neural networks have become a "fashionable" tool that is embedded in all possible products and services, without explaining its actual value.
Blockchain: Blockchain is a technology with huge potential, but it is often not used rationally. For example, instead of using more efficient databases such as IPFS, which do not burden the environment, many projects prefer blockchain, which leads to inappropriate energy consumption and exacerbates the problem of climate change.
Return to creativity:
We must return programming to its creative character. Programmers should become artists again, creating tools that solve real problems and make the world a better place. We must abandon the "factory" approach to programming and focus on solving problems rather than fulfilling orders.
New approaches:
In the following chapters, we will look at some new approaches to programming that can help bring programming back to its true meaning and make it more creative and human.
Chapter 4: Paradigms: A Dead End or a Guidebook?
In the programming world, we often hear arguments about which programming paradigm is better: object-oriented programming, functional programming, imperative programming, and so on. Each of them has its advantages and disadvantages, but often these disputes escalate into religious wars, where adherents of one paradigm consider all others to be "heretics".
Paradigms as a religion:
Programming paradigms are not absolute truths. They are tools that help us solve problems. But instead of using them as tools, we often start worshipping them, considering one paradigm to be "right" and all the others to be "wrong."
Example: Disputes about "clean" code:
We often see arguments about what "clean" code is. Adherents of one paradigm may believe that their style of writing code is the only correct one, and criticize others for deviations from their "canons".
Finding a balance:
It is important to remember that there is no single "correct" paradigm. Each paradigm has its advantages and disadvantages, and the choice of one or another paradigm depends on the specific task to be solved.
Freedom and structure:
Paradigms can help structure code and make it more readable and maintainable. However, excessive attachment to paradigms can limit a programmer's creativity and freedom.
The question is not "what is better", but "what is more convenient":
Instead of arguing about which paradigm is "better" or "faster", we should ask the question: "Which paradigm is more convenient and effective for solving a specific task?"
Example:
If you need to create a simple script, then perhaps imperative programming will be more convenient than functional programming. But if you need to create a complex system with multiple dependencies, then functional programming can offer a more structured approach.
Conclusion:
Paradigms are tools, not religion. Don't be afraid to experiment with different paradigms and choose the one that best suits your task and, most importantly, YOU PERSONALLY. Remember that it is important not to blindly follow the rules, but to find a balance between structure, ease and freedom in programming.
Chapter 5: Typing: Control or Limitation?
In the world of programming, the eternal debate is around typing: static or dynamic. Each of them offers its own approach to data type control, and each of them has its pros and cons. But as with paradigms, the debate about which typing is "better" often becomes meaningless and generates no less religious wars.
Static typing:
Static typing requires that the data type be defined at compile time. This allows the compiler to detect data type errors even before the program is started. This approach increases the reliability and security of the program, as it reduces the risk of unexpected errors.
Advantages of static typing:
• Increased reliability: Detecting data type errors in the early stages of development makes the program more reliable.
• Better readability: Explicit data type makes the code clearer and more readable.
• Improved refactoring: Changing the data type becomes easier and safer.
Disadvantages of static typing:
• Limited flexibility: Defining data types at an early stage may limit the flexibility of the program.
• More complex development: The need to explicitly define data types can slow down the development process.
Dynamic typing:
Dynamic typing allows you to determine the data type during program execution. This makes programming more flexible, allowing you to work with data of various types without explicitly defining their types.
Advantages of dynamic typing:
• Increased flexibility: Dynamic typing allows you to work with different types of data without restrictions.
• Simpler development: There is no need to explicitly define data types, which speeds up the development process.
Disadvantages of dynamic typing:
• Less reliability: Data type errors can occur during program execution, which can lead to unpredictable behaviors.
• Reduced readability: The lack of explicit definition of data types can make the code less readable.
• Difficulties with refactoring: Changing the data type may lead to unexpected errors in other parts of the program.
What's the matter?
As with paradigms, there is no single answer to the question "which typing is better". It is important to choose the one that is best suited for a specific task and development style.
Typing "simplifies" programming, but limits its capabilities:
Static typing can make programming simpler by reducing the number of errors. However, it can limit the flexibility of the program and complicate refactoring.
Typing is a tool in the hands of the developer:
It is important to remember that typing is a tool in the hands of the developer. The developer should choose the type that helps him solve problems more effectively. You should not blindly follow "fashion trends" and choose typing just because it is "popular".
Conclusion:
Typing is not a goal in itself, but a tool for achieving goals. It is important to choose a typification that will help you create reliable, flexible and readable software. Don't be afraid to experiment and look for what works best for your needs.
Chapter 6: Marketing in Programming: Fashion or Technology?
The world of programming is filled with HYPE. New languages, frameworks, and libraries appear with enviable regularity, promising revolution and revolution in the industry. But often this HYPE hides just a clever marketing ploy, the purpose of which is to attract attention and make a profit.
Marketing and hype:
Marketing plays a huge role in creating a HYPE around technology. Companies and individual developers invest heavily in advertising and promoting their products to attract the attention of programmers and investors.
Perception management:
Marketing not only creates HYPE, but also manages the perception of technology. Advertising campaigns often create the illusion of a "breakthrough" technology that solves all problems and opens up new opportunities. In reality, the technology may not be as effective as it seems.
Example:
Blockchain is a vivid example of a technology around which a huge hype has been created. Blockchain has been presented as a "revolution" that will change the world. However, in reality, blockchain is just one of many technologies that has its pros and cons. Marketing has created the illusion of a "breakthrough" technology, while in reality blockchain is just a tool that has its limitations and is not always suitable for solving all problems.
Dictating trends:
Marketing also plays a huge role in shaping opinions about languages and technologies. Companies and individual developers often try to "dictate" trends and inspire programmers with the opinion that one technology is "better" than another.
Example:
Last year, there was a huge hype around the Go and Rust programming languages. Marketing campaigns presented them as the "future of programming", and many programmers began to learn these languages without understanding their real advantages and disadvantages.
How to distinguish "fashion" from "technology"?
It is important to be able to distinguish "fashion" from "technology". "Fashion" is a trend that passes quickly, and "technology" is a tool that has lasting value.
How to avoid the influence of marketing:
To avoid the influence of marketing and not succumb to HYPE, you need to:
• Critically analyze information: Do not trust advertising campaigns and "revolutionary" promises. Learn the technology yourself, read the documentation, look at code examples, and talk to other programmers who use it.
• Don't chase "fashion": Don't learn new languages just because they are "popular". Choose the languages and technologies that are best suited to your tasks.
• Develop critical thinking: Don't give in to information noise and think for yourself.
Conclusion:
Marketing plays a huge role in programming, but not always in a positive way. It is important to critically analyze information and not give in to hype. Follow your interests and choose technologies that really solve your problems, not those that are just "trendy".
Conclusion: A new paradigm: Programming as self-expression
We have come a long way, from simple tools to complex systems, from creativity to execution, from the search for truth to entanglement in marketing networks. But what's next? How can a programmer regain his freedom and creativity, how to make programming truly human?
Programming as an art:
Programming is not only a solution to problems, but also a form of self-expression. Each programmer is an individual with his own style and preferences. It is important not to forget about this and not try to cram everyone into a single framework.
The choice of language is a matter of personal taste:
Choosing a programming language is not only a practical matter, but also a matter of personal taste. It is important to find a language that is convenient for you, that you like, that helps you express your ideas and solutions more naturally.
There is no "right" language:
There is no "right" programming language. Each language is a tool with its own advantages and disadvantages. It's important to choose a tool that helps you create, not one that "dictates" how to do it.
Programming is not an "arms race":
Choosing a language is not an "arms race" where you need to use the most powerful and complex tool. It is important to choose a tool that helps you achieve your goals quickly and efficiently without complicating the development process.
Return to independence:
We must return to the idea of self-reliance in programming. We should use languages and tools that help us express ourselves, not that "dictate" how to do it.
A new paradigm:
The new programming paradigm is programming as self-expression. This is programming that is convenient, accessible and understandable. This is programming that does not require a programmer to have in-depth knowledge of complex tools and theories. This is programming that helps the programmer to express his ideas and solutions more naturally.
Conclusion:
Programming is a creative field. We have to give him back his creative character. We should use languages and tools that help us express ourselves, not that "dictate" how to do it.
Instead of an "arms race," we need to create a "world" where programming serves people, not the other way around. And it will be a real revolution in programming.
Top comments (0)