What programming language to learn in 2018 and why?

    If you strongly want to join the compiler development team or the “Wild West World”, then feel free to choose and learn the top programming language from TIOBE and best of all: at the level of its specification. But seriously, now in the industry everything is so confusing with logic and conclusions, so much marketing and water that the most advantageous strategy is to turn on our own brains and make an express reassessment of the technical values ​​to which we are so used. In the post I will try to as clearly as possible orient the developers who are beginning their careers on the risks of choosing technologies and make the right and far (far away) reaching conclusions.

    Have you matured or not yet?

    Children differ from adults in the understanding of the word "responsibility". Unfortunately, not all children grow up on time, and some of them die in diapers. There is nothing terrible here - except for one thing: children in a team of programmers make others suffer a lot, especially when the deadlines are on and the release is close: either they are suddenly dressed in the middle of an open space, or they require a nipple during the brainstorming of the subject area with client representatives.

    Adults differ from children in understanding the key principle of IT management: “programming is a privilege”. Among experienced and successful fellow developers, the most adequate ones are well coded and “move the company forward” at the same time.

    IT industry is crazy

    Yes, we are people and are prone to emotions. But until now, no one knows how to properly program, although more than 50 years have passed since the invention of the computer. No one! Everyone is just hysterical and trying to attract more and more supporters to their camp, while tempting the business to create a project for themselves :-) Let me explain with an example.

    The speed of the brain

    The fact is that the first computers worked really slowly, very slowly, and were very expensive. Therefore, the first programs were written in very low-level languages, and sometimes right on machine code. Nowadays, such “prehistoric” technologies are sometimes used, but point to point: for creating operating systems and their components (close to hardware), for game engines, for high-performance libraries and servers , for cryptocurrencies, and, of course, for creating programming languages .

    And if C , despite its total leakiness and high danger for the developer, turned out really good and won the hearts of connoisseurs, then C ++It turned out to be an unusually ugly and controversial creation - but what to do is life. Maybe Rust , with the right ideas about how to safely work with memory, will affect the situation for the better, but due to the ugliness of syntax and unreadableness, he seems to have left C ++ far behind.

    The situation is further aggravated by the appearance of Golang . On the one hand, there is nothing new in it, the dembel's chord of the great Ken Thompson : only pitiful remnants of the possibilities of Java. On the other hand, it has become really easier to write “relatively” systemic and multi-threaded software, and this is a fact that many companies have appreciated :-)

    In this camp, you will find mostly deeply knowledgeable low-level technologies and the hardware of “real” hardcore bearded programmers, who, as a rule, taught one programming language - but all their lives they fall asleep with the specification of the compiler instead of the wife. Truly - in this camp cool people. And if you don’t know what processor x86 commands the yield in python is decomposed into - shame on you and shame. Therefore, the advice - avoid this camp until you finish reading to the end of the post.

    But there is a downside. Projects here are made not only for a long time, but ... for decades. Low-level programming languages ​​are not what help, but on the contrary - interfere. Constant violations of work with memory occur, dozens and hundreds of testers are required (or you can put it on github and we will collectively test with you) and thousands of unit and other types of tests, so that “it takes off” . Many developers who joined the team at the start of projects do not live to see the release and die of old age, helping beta testers to the last breath. But these courageous people, before bleeding from the eyes, before the advent of stigmata, do everything possible and ... masterpieces are born .

    Architecture and Enterprise "brain"

    Because still no one knows how to program properly, a camp of “competent design and reliability” was formed by natural selection. You are crazy about programming in languages ​​that allow unsafe memory operations through pointers - you can also bring the world to an apocalypse: "segmentation fault in the software of a nuclear reactor." How can one begin to do a project without the support of strong typing in the language ?? And they invented the next correct programming languages: Java and C #. But in Java they forgot about the harm of null-values, and in C # they did not fully consider backward compatibility. The result was a huge corporate, relatively safe and relatively backward compatible world. In this world, a goal is measured by lines of code per day (usually not more than a few dozen,OOP . One of the main mottos of the camp is “why do it simply, if you can… difficult and reliable, for a long time, for centuries!”. And some of them can still write quickly and elegantly, washing hands with blood and collecting the structure of the project in their heads every morning, while simultaneously looking at 3 monitors. But some people are so addicted that they continue to create hierarchies of hierarchies within hierarchies of hierarchies to infinity - and the goal has long been lost, and the eyes continue to burn and my hands itch.

    In fact, in areas where the subject area is well settled and fits into “objects with status and communication between them” - this approach works very well.

    Particularly pleased with the “strict” (quotes, because what’s next about haskell) static typing (this is when entity types are known in advance, they are checked by the compiler and you can’t add a line to the number) ease and pleasure when refactoring and improving the code and high not to say great, the quality of development environments. Colleagues in this camp are often very educated in software architecture, read a lot (entry threshold is high), understand the capabilities of numerous platform libraries, design patterns, techniques for writing tons of documentation and creating automated tests, tests of these tests and can write for months the mock that will turn out not needed. Again - often projects are being made and run for quite a long time, by large teams, numerous testers are required, but the nature of errors is an order of magnitude less fatal, which inspires. Getting into this "caste" of enterprise development is very difficult. If you demonstrate how in PHP you can solve a problem in 5 lines, which your java colleagues will solve in 5 days - you will be burned alive in a microwave :-)

    The reliability of the "brain"

    In the academic environment, another camp has emerged, very interesting and recommended for understanding, and a set of functional programming languages ​​(Lisp, Haskell, Erlang, and others). Are you crazy programming with the use of variables and cycles - you can also make a lot of mistakes! A program is a set of function calls, and instead of cycles, use recursion, gentlemen! OOP? No, not heard - typeclasses and algebraic data types. You do not know about applicative functors and did not leaf through the theory of categories - yes you are not developing your own brain, my friend.

    In fact, in my opinion, in order to enter this camp and understand its values, you need to strain your brains very sooo very much - for mathematics will be a sea and even more unexpected, but wonderful concepts. The experience gained in this team will be invaluable and will be useful when working with other programming languages. They say that someone sometimes uses functional languages ​​in real projects: compilers, cryptocurrencies - undoubtedly, your projects will be orders of magnitude smaller than logical errors that the compiler will catch, and the conciseness and clarity and conciseness of the Haskell code, of course, is amazing - but in the era of “laputena!” the number of those who study and understand this beauty is becoming less and less.

    The result and the effectiveness of the "brain"

    To hell with architecture and PLO, brother! Cthulhu loves you, and duck typing is the key to success! Strong typing? And who in their right mind would assign a string to the number ?? Static typing and compilation is a waste of time, because the code is written once and if it does not have time to write to the release, it will be thrown away (and they will be thrown away, but a little later). Refactoring? Immediately write correctly :-) Encapsulation? Put a dash in front of the variable name and everything . OOP is a re-complication without need. What the hell compilation - F5 and see the result. Design patterns - no, you have not heard: our scripting is all ... Do you want to be weed?

    The most interesting thing is that when you delve into languages ​​with dynamic typing (strict in python, non-strict in php and javascript), you gradually open your eyes to the real picture of things, because:

    • the code becomes very clear and concise and you don’t need to climb up to 20 classes (if it’s not related to system libraries)
    • you can quickly check the idea through the REPL
    • Languages ​​are simple, often minimalist, contain necessary and powerful primitives (lists, dictionaries), which, most importantly, are placed in your head!
    • there is a cloud of libraries and you can always solve any problem in 5 lines

    And to hell with refactoring :-) Life has become more fun (I hope a developer who supports my code will not know where I live). In this camp, you will often find many cheerful people of completely different specialties, apart from “programming in assembler”, who are able, nevertheless, very quickly and efficiently, to solve problems in 5 lines and to maintain code and web projects for a long time and successfully.

    Look at the latest trends in this camp and imbued with this philosophy of happiness. Simple and clear programming environment in the browser , well, what could be sexier?

    And how easy is it to raise a non-blocking web server that serves thousands of connections in 10 lines per node.js and the community grows by leaps and bounds?

    And no “Eclipse XML Soap Entiny beans enterprise OOP ...” - json and csv and smile (and the smell of an unknown plant). At the same time, the code is read and placed in the brain, and therefore, it works happily for a long time and is supported with the same ease for many years.

    And it turns out that “so” can also be successfully programmed and the years spent in “industrial programming languages” are lived in vain (but the fingers became stronger).

    Technology selection

    Are you in shock? So do I. And imagine the amazement of the customers who choose the technology to implement a business project! :-)

    I think you are well aware at the moment that the IT world has really gone crazy and lost (just kidding). Some programming languages, such as Scala, are trying to sit on all the chairs, but this is not yet very successful with them - it becomes difficult to understand the code to mere mortals. But seriously, the competition of programming paradigms will only intensify because ... the tasks in the projects are completely different and it is from the tasks that you need to “dance”! In a fixed domain (servers, libraries), nominal typing is better suited (C ++, Java, C # ...), it will be better with structural typing somewhere(Golang, Haskell ...), and in web scripting or machine learning tasks, real happiness will come with duck (python, php, javascript ...). No need to think that static typing , especially strict, is directly “must have” - you will fail the deadlines and the code with a satisfied paranoid thought about “possible errors” will be thrown into the garbage. On the web, scripting and machine learning, you can confidently move forward at high speeds and with dynamic duck typing and php and python with a huge number of excellent and powerful libraries. This is a good example.

    So forget about “what to learn programming language in 2018” to hell:

    • Understand the programming paradigms (OOP can be a grave, or it can save you a project)
    • understand the subtleties of typing and the associated risks and opportunities (you can damn dynamic typing in the financial library, or sacrifice Cthulhu of a java programmer and rewrite it 100 classes on 100 lines in a script that even children can understand)
    • understand the algorithms at the level of intuition (you need to distinguish search from sorting, and a neural network from logistic regression - and to understand further, you have to learn ... all your life, but it's worth it)
    • understand that experienced developers (although no one knows where to find them on the market) implement the project on almost any technology (even on a brainfuck) and do it well, but the inexperienced will have to choose a programming language with the most comfortable level of entry and the risks of collapse great anyway

    Next, select the area of ​​tasks that you will be interested in doing, for example the web or machine learning and:

    • look at what people solve these problems
    • scatter according to the criteria above the risks and opportunities of each instrument
    • Sit a couple of weekends with 1-3 specific tools, but not up to fanaticism or specifications.
    • quickly get down to business and gain experience in the use of tools in practice - this is the most important thing
    • There is no need to learn the programming language “to the end” - better learn the way to solve your problem in the 5 most popular tools in 10-15 lines and you will actually be extremely adequate!

    Case Study - ML

    Suppose you are interested in machine learning ... Congratulations! On the one hand, there is an academic theory - but you have to pull out the essence of mathematical statistics and linear algebra from it and in no case hang on many months of courses (go, believe me, crazy if you are not a mathematician, but a humanitarian ). On the other hand, you need to learn how to quickly write useful code and solve a puzzle in 5-15 lines. Yes, you can write everything in C years after 10,000, so you look at the experience of colleagues and choose, correctly, python, which has a lot of libraries and ready-made solutions on this topic. You devote a couple of days off to studying python - there’s nothing more to learn, the language is very simple (and we agreed not to go into the wilds, because time is money).

    Additionally, read about the essence of numpy, pandas, scikit-learn and, if eyes are burning, then Keras and go ahead, make projects. But you can go the other way, long, difficult and leading to personal holiness and social poverty (understand after 3 years the essence of the algorithm, selling newspapers in the train, but it can be such a special way) - start implementing the algorithms yourself, with manual memory management, or introduce a heavier solution and bury the code for months. The wrong tool is the key to sleepless nights and wasted time — avoid complexity by all means.

    An improperly chosen tool, even the most popular one, even as a free gift, even if it is theoretically possible for everyone in the future, can ruin a project for you by failing all the deadlines. Minimize this risk as much as you can and cannot.


    So, friends, we were convinced with you that no one knows how to program correctly and successfully, even we, the developers :-) The competition of programming paradigms and technologies is increasing, the head swells, and free time becomes less. Therefore, the most winning strategy of a developer who starts his career is to drink a jar of cool beer, relax and:

    • avoid sticking and immersion in excessive technological details, the number of which is growing exponentially
    • choose an interesting task area in which you are interested in solving customers' problems
    • learn to extract from the tools and programming languages ​​a short and erotic essence
    • write as little as possible, but clear and understandable to you and the people around you
    • learn how to solve problems in 5-15 lines, not 20-50 classes
    • if you want to go somewhere else, then let it be fundamental things like math, haskell or rfc by tcp / ip
    • get the pleasure of programming and warm them to your colleagues!

    And always remember that time, especially free time, is a valuable resource and it depends on us where to invest it. Good luck to everyone and good mood!

    Also popular now: