My sister, her husband and I (the older generation) were sitting at the dinner table with their two children (the younger generation), discussing computer science.

One of the members of the older generation said, "From what I understand, most programming (except for cutting edge applications like nanotechnology) has already been done, and can be looked up. A lot of computer science nowadays is choosing and cutting and pasting the formula that most appropriate/efficient for your application. This was different from "my time," when there was a much greater emphasis on discovering new ways/languages, for programming."

One of the younger generation agreed that computer science nowadays was much more of a "copy-editing" job than what she remembered from her teachers' descriptions.

Has computer science/education in fact changed in this way within the past three or four decades? Assuming that it has, what would be the implications for classroom practices today? (For instance, when I was studying computer science in the 1970s, very limited use was made of "library" functions, and we were encouraged to do things from scratch.)

  • 1
    $\begingroup$ When it was said, "most programming can be looked up" were they referring to things like Open Source, or other pre-written or pre-defined libraries or collections? It would be like saying that most woodworking has already been done, we can just fit together wooden parts, because the power tools are so widely available. Programming is partly about creating the means to do something, and partly about actually doing it. The actually doing will go on, no matter how good the means have become. Deciding what to do and how to use a power tool is still a creative activity. $\endgroup$
    – Scott Rowe
    Commented Aug 20, 2018 at 13:57
  • $\begingroup$ I'm not sure if this is quite on-topic for the site, as written. It seems more like a history question than a problem needing a solution. Perhaps, with the acknowledgment of the difference between practice now and instructor descriptions given by the younger generation, a better question might be about converting classroom practice to accommodate that change. $\endgroup$ Commented Aug 21, 2018 at 14:50
  • $\begingroup$ Uh... better interfaces, better documentations, powerful PCs. Need I go on? $\endgroup$ Commented Aug 25, 2018 at 0:31
  • $\begingroup$ not only better software, if you give a review for example to mysql or even if you see forks like mariadb these days are wonderful $\endgroup$
    – user5980
    Commented Sep 27, 2018 at 3:33

4 Answers 4


I think this question is confusing "Computer Science" and "Software Engineering" / "Software Development" / "Programming".

Computer Science has nothing to do with "cutting & pasting code".

Type Theory is hotter today than it ever was, Type Systems can do more things than they ever could, Programming Language Theory is blooming, Compilers perform optimizations that would make Admiral Hopper's head explode, companies like Microsoft not only use Automated Theorem Proving to prove (parts of) their code correct, they actually employ researchers, scientists and engineers to invent those tools in the first place.

Mainstream programming languages are more and more based on principled, rigorous, mathematically proven foundations, for example look at the evolution of Scala and the Calculus of Dependent Object Types. We have projects like seL4 and L4.verified that produce a mechanically proven correct microkernel. In combination with a verified C compiler (which now exists), a verified assembler (which now exists), and a verified CPU (which now exists), you have a system that has been proven correct from the OS layer down to VHDL. Once you get a verified VHDL compiler, you have a system that is proven correct down to the transistor level.

We have entire subfields like Quantum Computing and Bioinformatics which not that long ago didn't even exist.

Average web programmers now know about things like Monads, Promises, Futures, Vector Clocks, the CAP Theorem. Working programmers in industry casually throw around sentences like "an infinite event loop is actually just finite co-recursion over co-data" and use concepts like monads, co-monads, functors, co-functors, bifunctors, arrows, categories, catamorphisms, hylomorphisms, homomorphisms, isomorphisms, monoids, semigroups, groups, fields to structure their programs.

All told, a monad in X is just a monoid in the category of endofunctors of X, with product × replaced by composition of endofunctors and unit set by the identity endofunctor.

For example, the IObservable/IObserver pair of interfaces in .NET was mathematically derived as the category-theoretical dual of IEnumerable/IEnumerator. That is CS applied to library API design of one of the most widely-used libraries.

Many programs nowadays are asynchronous, concurrent, parallel, or distributed, or even all of the above. How to make that safe, performant, and accessible to the average programmer (or even non-programmers) is an active area of research in Type Theory, PLT, and Compilers.

  • $\begingroup$ I'm pretty sure that your "average" web programmer does not know all of the things you suggest. I just polled four of them from three different companies, and only one had even a notion of what a monad was. It's a small sample, but I'm fairly certain that if you polled 10,000 web programmers at random, you wouldn't get anywhere close to a simple majority. $\endgroup$
    – Ben I.
    Commented Sep 7, 2018 at 17:12

Like any field with an active research community, Computer Science changes over the decades, sometimes quite drastically. If a practitioner doesn't keep up he or she will be left behind, not understanding the new work.

Decades ago problems tended to be a bit smaller in scope. How do I sort an array? Now they are massive. How do I scale a cloud environment and make it immune from failure and attack?

For this change in scope and scale to occur we need to learn to think at higher and higher levels of abstraction. It is hard to write complex programs in languages that permit only simple constructs.

Language research is still an active pursuit. The ACM still has a special interest group POPL interested in the Principles of Programming Languages, for example. The papers and discussions are deep and "modern."

There are many other ACM SIGs, some of which, say SIGMobile, couldn't have existed a couple of decades ago, prior to smartphones.

The other thing is that such a field grows so much that no single practitioner can grasp all of it after a certain point in time. In mathematics, for example, this point was passed around 1900. It has probably been passed in CS as well.

Regarding education, the changes in the field have also generated changes in teaching, both the content and the methodology. I can speak only for what happens in the US since all my experience is here. But an undergraduate CS major will get two things. First a broad education, including History, Philosophy, and the rest, including some writing. Second they will get enough education in the major field to either go on to a graduate degree or obtain an entry level position in industry. But they will normally never be deeply taught in any one aspect of CS (or Math, or Literature, or ...), nor broadly enough to say they know much about the whole field.

The Master's degree, on the other hand should, in a technical field teach students the things that every working professional needs to know. Again, this isn't necessarily very deep nor broad, but it has to be vaguely comprehensive for the working pro. It should also get you a bit closer to the ability to do research if it doesn't already include some research component. But usually the research required there is into what is known about a possibly new or arcane topic, rather than the creation of new knowledge in a field. That is for doctoral programs.

The effect of this is that undergraduate teaching now includes more options that were not studied in the past (big data, machine learning, ...) through elective subjects at the upper level. It also means that some things that were needed by working pros in the past (numeric algorithms, say) are not taught to the same degree as much of what was once hard is now captured in standard libraries. But methodologies also change, and now teamwork is much more used in the classroom than was typical a few decades ago.

The conclusion I draw from all of this is that students need to start higher up the learning tree if they are to get where they need to go. In my view, recapitulating the history of computation, starting with low level concepts and tools and building everything up incrementally is a mistake. There is also no need. Students can start at any level of abstraction and work upwards from there intensively. They make excursions down the abstraction hierarchy on occasion as some of that helps the understanding, but a complete understanding of the foundations of, say, IEEE Floating Point algorithms is only needed by a very few working pros. If you start the education, today, the same way it was done 20 years ago there will be no time to get to today's problems and solutions.

I used to tell my students that my job is not to teach them what I know, because much of that is now obsolete. My job was to teach them what they need to know. Not the same thing. One example is the hidden bit in IEEE Floating Point.

  • $\begingroup$ Actually, @ScottRowe, a field grows with the size of its practitioners. Math grows fast also, but there is already so much of it and so many practitioners that you can't see much of the horizon. Much like the universe itself. $\endgroup$
    – Buffy
    Commented Aug 20, 2018 at 20:03
  • $\begingroup$ @scottrowe I don't think it has changed very fast (Hardware has improved very fast, exponential growth, but software has not always even been positive). see bret victor's future of programming youtube.com/watch?v=8pTEmbeENF4 it is set in the 1960s, but aimed at people in the 2010s. Why don't we learn, from what has been done before? Why is software getting slower?, using more memory? $\endgroup$ Commented Aug 21, 2018 at 10:44
  • $\begingroup$ @ctrl-alt-delor I challenge that we haven't learned from the old stuff. A lot of it is just in the libraries now. You don't need to build a lot of the things today that you needed to in years past. We have faster, bigger machines so that (a) the optimization that every programmer needed to do in the past in every program is now less important and (b) much of it is done by the compiler and associated tools. The problems that we can now solve are also bigger now and were infeasible in the past. $\endgroup$
    – Buffy
    Commented Aug 21, 2018 at 10:54
  • $\begingroup$ @ctrl-alt-delor I have definitely watched "The Future of Programming" and showed it to my students. Bret seems to have disappeared from the public stage, the past few years. I wonder what he is doing now? $\endgroup$
    – Scott Rowe
    Commented Aug 21, 2018 at 12:34
  • $\begingroup$ @ScottRowe. Sorry, your metaphor fails the smell test. People to teach beginning students starting at a higher level than the absolute base. I have a doctorate and fifty years of experience. I know quite a lot. Do I expect my students to follow my path in every detail to learn what I know. That would be profoundly stupid. And if they did it they would be 70 years behind the curve. You are ignoring the power of abstraction. Sorry. No. $\endgroup$
    – Buffy
    Commented Aug 21, 2018 at 12:35

Computer Science and Computer Education has not fundamentally changed from decades ago, but have evolved.

For instance, if you were getting an IT education in the year 2000, you would need the following:

  1. A floppy disk
  2. A computer (very expensive and few people had it)
  3. You probably used Encarta (internet was a very expensive and not very well known option)

So at a college level for example if you needed to learn abour programming languages, the better option in fact was your library university or books.

What happens with kids and boys and girls today?

They have the following in their own homes or easily available:

  1. internet even on mobile phones
  2. online sites like: Youtube, Wikipedia, etcetera.

Books for example are available in two ways:

  1. Online(PDF)
  2. Physical form

An even a better example right now is that it is common to use an online storage service instead of physical storage, so even USBs are an old fashioned tool.

In the educational field for example, my IT or programming teachers learned about C++, Pascal or Basic as trending technologies. Right now some of them feel out of date with today's technologies.


It doesn't matter if you're talking about about using a smartphone, programming an app, or making a website; since the 90's, it has evolved. Today there is a massive marketing so that everyone can see about benefits studying for an IT degree: jobs, popularity, income, etc

Today is very common to see young people at tech events, learning through IT platforms, or making Youtube videos teaching about IT. Today IT is popular!


For background, I'm answering this question as an individual who got an engineering degree, spent 30 years programming in industry, and now teach and mentor at the local university.

In many respects, I really don't see a big difference from the late 60's until now. Our program still contain the same types of components: computation and assignment; conditionals; repetition and abstraction. I began with Fortran IV and though it lacked both structures and dynamic memory, one was able to get around that by using "parallel" arrays for lists of structures and by allocating huge arrays and managing the contents with our own "pointers".

One big change, however, was in turnaround time. With punch cards, it was often many minutes if not hours before one received "feedback". The consequence of this was that one had to carefully review programs before submission. As soon as "personal" computers were introduced, the feedback became almost instantaneous. This altered my approach to programming as it became possible to code small pieces and test them before moving on to the next piece. I'm surprised that students do not take advantage of this. Rather, many tend to code way too much before testing anything.

The other day I was discussing with a student how to do an assignment. It had three basic parts: read in some data; transform the data; write out some data. I suggested that the student first code the input and output, skipping the transformation entirely until the other two parts worked correctly. The student was baffled by this because the assignment required all THREE parts. "Yes is does, but ONLY when you have completed it". I'm not sure I got through.

Of course, many things got easier as I progressed to Pascal, then C with unix and all of its functionality provided by the shell and the ability to stitch things to together with pipes. Then came Java, C++ and networks. And on to concurrent programs and the many languages that came with the web. Faster hardware made slow programs really quick and allowed work on even bigger problems. I love the choice of languages and the ability to build solutions using several languages. All the standard libraries mean I don't need to reinvent the wheel, but merely integrate well proven code into my program. IDE's and many other tools have made me more productive.

Prior to the web I was limited to the reference texts I had available and the knowledge of those that I worked with. Today I can get thousands of answers to a question, but must sort through and evaluate them for accuracy and appropriateness. A textbook, such as K&R, that was once a necessity on my bookshelf has been replaced by the ability to search the web. I still find discussing things with colleagues to be the most beneficial approach to problem solving. That has stayed constant over the years.

I'm probably like a lobster in a slowly warming pot and don't realize how much things have changed. Yet I look back and don't find the process I use terribly different from years ago. I spend a lot of time thinking about what I'm trying to do, selecting the appropriate technologies and putting it together, piece by piece, with continuous testing. I can't say that my experience is typical as I have been out of industry for more than 10 years. However, my approach and experience has been valued in teaching.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.