Translation of Bjarne Straustrup's article “What should we teach new software developers? Why? ”

    The January issue of Communications of the ACM published a short article by Uncle Straustrup about problems in teaching computer science. The article is far from certain and certainly strongly oriented towards American society, but interesting and quite relevant for us. Translation (somewhat literary, but close to the original) I bring to your attention and discussion, those who want to improve it - welcome here



    What you need to teach young programmers and why.


    In order for the industry to live better, fundamental changes in the teaching of computer science are needed.

    Computer science should be at the center of the development of software systems, otherwise we should rely on individual experience and rules of thumb, getting less productive and reliable systems with an unacceptably high cost of development and maintenance.

    What is the problem.

    In many places, there is a gap between what industry needs and what university programmers teach. Here's an example:

    The famous professor of computer science, proudly: "We do not teach programming, we teach computer science."

    Industrial manager: "They cannot program the most basic thing!"

    In many cases, both are right, and not only at first glance. It is not a university matter to graduate average programmers, but industry needs not only "high-level thinkers with a broad outlook" and "scientists."

    Another professor of computer science: “I never program.”

    Another manager:“We do not hire graduates of the department of computer science. It’s easier to teach a physicist how to program than to teach a physics graduate of this department. ”

    They are both right in some ways, but in an ideal world, both would be fundamentally mistaken. The professor is wrong, because it is impossible to teach that which you do not practice (and in many cases have never practiced), and therefore you do not understand, while the manager is right only when the requirements for software quality are so low that with Physicists and other people not trained in computer science will cope with them. Of course, I do not mean those physicists who spend a lot of energy on computer science - such a set of qualities would be ideal for me.

    Professor of Informatics (about the student): “He got a job in industry.”

    Another professor of computer science:“It's a pity, because he showed great promise.”

    This inconsistency is at the heart of many problems, and complicates attempts to fix them.

    Industry wants graduates from the computer science department to program, at least at the beginning of their careers. Often they have to work with the long-established sources of some distributed or embedded system with high reliability requirements. Many graduates, however, have virtually no knowledge or software development skills, with the exception of any amateur entertainment. In particular, many see programming as doing homework with minimal labor and rarely think about deeper things, such as systematic testing, support, documentation, and the use of written code by other programmers. Many are also unable to combine what they learned in one lecture with what was told in another, and we often see students with good grades on algorithms, data structures and software engineering, which, however, in classes on operating systems were quickly coded with absolute neglect of all the same algorithms, data structure, and code. As a result, we get inhibitory and poorly maintained porridge.

    For many, “programming” has become a strange combination of unprincipled hacking and the use of foreign libraries (with a very vague idea of ​​what is actually happening). The concepts of “support” and “code quality” are usually forgotten or not completely understood. In industry, complaints about the difficulty of finding graduates who understand “systems” and “can design software” are already familiar and reflect reality.

    But lately, my computer has been hanging

    Complaining about software is pretty fashionable, but over the past decade, many programs have improved, just like they did in previous decades. Unfortunately, we pay a huge price for improvements with human and machine resources. In general, we learned how to build relatively reliable systems from unreliable parts by adding endless layers of checks during program execution and mass testing. The structure of the code itself has sometimes changed, but not always for the better. Often multilayer software and complex dependencies prevent a programmer, even if he has seven spans in his forehead, from fully understanding the system. This does not bode well for us, for we do not understand and cannot even measure the critical aspects of our systems.

    Of course there are engineers who have resisted the desire to build bloated, poorly understood systems. They should be thanked when our computerized airplanes do not crash, when the phones work, and the mail arrives on time. They deserve thanks for their efforts to turn software development into a mature and reliable set of principles, tools, and technologies. Unfortunately, their minority and bloated software dominate the feelings and thoughts of many people.

    Similarly, there are teachers who are struggling with the gap between theory and industrial practice. And they also deserve support and gratitude. In fact, all the educational institutions that I know strive to teach practical knowledge and there are professors who have dedicated their lives to promoting some of the individual programs. However, a larger picture is not at all impressive. A couple of projects or internships are a good start, but not a substitute for a full-fledged approach to a balanced curriculum. The preference for “informatics” of the labels “software engineering” or “information technology” may indicate differences in perspective, but problems have a vile property to appear in new guises even after a change of scenery.

    My images of “industry” and “scientific community” are close to caricatures, but I’m sure that everyone who has at least a bit of experience will see in them a reflection of a piece of reality. My perception is the perception of an industrial researcher and manager (24 years at AT&T Bell laboratories, 7 of them as the head of the department), who spent the last 6 years at the university (at the Department of Computer Science, Faculty of Engineering). I travel a lot and every year I have serious discussions with technical and management people from several dozen companies, mainly from the USA. I think the discrepancy between what universities produce and what production needs is a threat to both the viability of computer science and the computing industry.

    The gap between theory and practice

    What do we do? Industry would prefer to hire “developers” who are fully trained in the latest tools and technologies, while the highest ambition of science is to produce the best scientists in large quantities. In order for us to make progress, these ideals need to be better aligned. Graduates going into industry should have a good understanding of software development and industry should develop significantly better mechanisms to absorb new ideas, tools, and techniques. It makes no sense to embed a good developer in a culture adapted to protect against the harm caused by semi-educated coders, because it will be difficult for a new developer to do something essentially new and better in it.

    Let me point out the problem of scaling. Many industrial systems consist of millions of lines of code, while a student can earn a degree in computer science without writing a program longer than a thousand lines. All large industrial projects involve many people, while many computer science training programs value individual work, essentially hampering group work. Understanding this, many organizations are simplifying tools, technologies, languages, and operating procedures in order to minimize dependence on developer skills. This is simply a waste of human talent and work, because it reduces everyone and everyone to the lowest common denominator.

    The industry wants to rely on time-tested tools and technologies, but at the same time prone to dreams of silver bullets, magic bubbles, killer applications and so on. She wants to be able to work with interchangeable coders with the minimum qualifications, led by “architects”, too serious to take care of such trifles as code quality. This leads to excessive conservatism in the selection of basic tools (such as programming languages ​​and operating systems) and to monoculture (to minimize training and deployment costs). In turn, this leads to the emergence of huge proprietary mutually incompatible infrastructures. Something needs to go beyond elementary tools so developers can write applications, while platform vendors want to somehow tie up developers, despite the commonality of core tools. Incentive systems reward grandiose corporate schemes as well as short-term results. As a result, both the costs and the number of failed new projects are staggering.

    Faced with industrial realities and other obstacles, science returns to itself and does what it can do best: carefully studies the phenomena that a small group of similar people can work in isolation, builds solid theoretical foundations and designs perfect designs and techniques for spherical horses in a vacuum. This model does not fit proprietary tools for working with huge quantities of source codes written in an archaic style. Like industry, science invents appropriate incentive schemes. All this fits perfectly into the continuous improvement of courses flying into the pipe in well-defined scientific subjects. Thus, scientific advances fit industrial needs just like a square gag of a round hole, and industry must bear the cost of training,

    There will always be someone who thinks that if industry paid decent wages to programmers, then there would be no problem. This may make sense, but just a big fee for the same work will not help much, because the industry actually needs better developers. The idea of ​​developing software like a pipeline serviced by low-skilled, interchangeable workers is fundamentally flawed and unsuitable. It pushes the most competent people out of this sphere and in no way encourages students to study such a science. In order to break this vicious circle, more graduates with adequate skills should leave universities, and industry should adopt tools, techniques, and processes that can use these skills.

    Dreams of professionalism.

    “Computer Science” ( Computer Science, still translated in this text as “computer science” - my note ) is a terrible and misleading term. Basically, it is not about computers and basically it is not a science. Rather, it is about using computers and about ways of working and thinking that involve computing (“algorithmic and computational mindset”). It combines certain aspects of science, mathematics, and engineering, often using computers. For almost all people involved in it, computer science is an applied field. "Pure computer science", in isolation from applied use, is usually fruitless.

    What is the difference between the two people building the application, one of whom knows computer science, and the second is a professional in some other field, for example, in medicine or in physics? It must be that the first is fluent in the fundamental foundations, the "core" of computer science. What could it include? Most of the established course in computer science is algorithms, data structures, machine architectures, programming principles, a bit of mathematics (mainly for logical and numerical thinking) and computer systems (operating systems, for example, or a DBMS). To gather all this knowledge together and get an idea of ​​how to work with large tasks, each student should participate in several group projects (you can call it elementary software engineering). The essential thing is that there must be a balance between theory and practice. Computer science is not only principles and theorems and not only stupid coding.

    This core is obviously much more computer-oriented than computing science in general. Therefore, we cannot call anyone an informatics scientist without adding specialization (for example, graphics, networks, software architecture, human-machine interaction, security). But this is not enough. Practical informatics is inherently applied and interdisciplinary, therefore, every professional in computer science should have some non-core education in some other field (for example, in physics, medical engineering, history, accounting or French literature).

    Experienced teachers may exclaim: “But this is impossible! What student can learn all this in four years? ” They are right: something must be sacrificed. I propose to make the master's degree the first, giving the right to practice as a computer scientist, moreover, a real master's degree, and not a bachelor's degree with an attached final year or two. Those who plan to further research will, as always, seek to obtain a candidate’s degree.

    Many professors will object: “I don’t have time to program!” However, I believe that professors teaching students who want to become professional developers should find time for programming, and institutes should find the means to reward such professors. The primary goal of computer science should be to help produce the best systems. So would you entrust the teaching of surgery to someone who has not seen a single patient for many years? What would you think of a piano teacher who never touched a keyboard? Studying a computer science by a student should go beyond reading the necessary books, in the direction of improving their application in the whole system and a sense of aesthetics of the code.

    I use the word professional. It has many meanings and meanings. In industries such as medicine and engineering, it involves licensing. Licensing is a very subtle and emotional topic. But our civilization depends on software. Is it reasonable that anyone can change the critical part of the code based only on their own taste and corporate policy? Even if so, will it still be reasonable after 50 years? Is it reasonable that the software that millions of people depend on has no guarantee? In fact, the problem is that the professionalism confirmed by the license depends on the presence of a large mass of generally available knowledge, tools and technologies. A licensed engineer can confirm that the building was constructed using generally accepted materials and technologies. I do not know how to do the same for software in the absence of a generally accepted competency scheme in computer science. Today, I don’t even know how to choose a group of people to develop a licensed exam (or, more realistic, a set of exams for different specializations, similar to a medical commission).

    What can industry do to close the gap? It is much more difficult to characterize “industry” and “industrial needs” than to talk about science. In the end, scientific institutions have a fairly standard structure and approaches to achieving goals. Industrial enterprises are much more diverse: large and small, commercial and not very, using advanced approaches in the construction of their systems and so on, and so on. Therefore, I cannot even begin to prescribe the medicine. However, I have one observation directly related to the gap between science and industry: many organizations that are critically dependent on computing have dropped to dangerously low technical level.

    Industrial manager: “if you want to survive - do not show anyone your technical abilities”

    An organization cannot remain successful without corporate memory and infrastructure for the search and development of new talents. Closer collaboration with scientists interested in software development can be productive for both parties. Joint research and an emphasis on long-term training that goes beyond simple training courses can play a major role in this.

    Conclusion

    We have to get better. Until we do this, our infrastructure will creak, swell and absorb resources and one day something will break in the most unpredictable and destructive way (think about Internet routing, online banking, electronic voting and managing electric networks). In particular, we must close the gap between science and industry, changing both sides. I propose to establish a computer education structure based on a core with specializations and application areas, aiming at licensing software products and at least some computer science professionals producing them. This can go hand in hand with the long-term support of technical experts from science and industry.

    Also popular now: