Compare with most of "legacy" mathematics, which studies countable structures (so the description can use arbitrary series).

Of course, there are larger sets, but they mostly serve as a theater (just like countable infinity is just a theater of computer science).

Finite sets in the rest of mathematics are sometimes considered uninteresting, but not so in computer science, where only very small sets (roughly of up to 32 elements, all subsets can be easily checked on a typical computer) are considered uninteresting.

Good example is number theory, which philosophically considers all natural numbers, regardless of size, to be equal type of objects. In computer science, the (although fuzzy) magnitude of numbers plays much bigger role.

This is a strange claim since the entire field was founded upon the investigation of potentially (and often actually) infinite computations.

> Compare with most of "legacy" mathematics, which studies countable structures (so the description can use arbitrary series).

Define "most". Do it in a way that makes real and complex analysis and topology (and probably many other branches) the smaller part of mathematics.

Most importantly though, my problem with this kind of discussion is that the question itself is meaningless. Not everything can be classified into neat " X is a Y" relationships. Not everything needs to be classified into such relationships. Even if the discussion reached a consensus, that consensus would be meaningless. Computer science is a part of math? OK, but so what? Computer science is not a part of math? OK, but so what? Neither conclusion would tell us anything useful.

I assumed the implication here is that CS, like math, is considered by many to not be a science, but rather a field of construction based on logic. The obvious problem with calling computer science a science is that it isn’t fundamentally based on measuring empirical evidence of a natural process. Maybe that still lands in the ‘OK, but so what?’ category, on the other hand this has been much discussed re: math, and it may be useful to clarify in what ways CS is not employing scientific method.

What leads you to say this? If computation is in some sense the construction of certain forms of mathematics, is computer science not then the empirical study of computers (the objects which instantiate the math) and computation (the process of instantiation)? Of course there is abstract theory as well, but that's just as true in physics

Newell and Simon had some thoughts: "We build computers and programs for many reasons. We build them to serve society and as tools for carrying out the economic tasks of society. But as basic scientists we build machines and programs as a way of discovering new phenomena and analyzing phenomena we already know about... the phenomena surrounding computers are deep and obscure, requiring much experimentation to assess their nature."[0]

The fact that digital computation is a new process doesn't make it "unnatural", it might be argued; some also contend computation takes place not merely in digital computers but much more generally, in which case distinctions between computer science/cognitive science/physics blur

Agree with your broader point, though. I'm not aware of any consensus on the epistemological or ontological status of computer science, or on its relation to the other sciences. It seems (to me) subject to many of the same philosophical questions that dog mathematicians, re: discovery vs. invention, the uncertain reality of various abstractions, generalizability, etc

Likewise agree that consideration of the methods employed in computer science can be fruitful, in particular if the goal is not so much to establish once and for all which category CS falls most naturally into, but simply to stimulate critical thought about the fundamental questions

[0]: https://dl.acm.org/doi/10.1145/360018.360022

I’d agree there are ways that we can observe computation as a scientist and form hypotheses and perform experiments, especially if, for example, I write a program I don’t fully understand and don’t know how to predict the behavior of, or more maybe much more commonly when I observe software written by other people.

Thinking about the analogy to telescopes, the implication is that computers are an instrument for measuring something. Telescopes measure things about planets and stars, physical things that occur in nature. But what exactly do computers measure if they’re to be considered a measuring device? It’s fun to think of a computer being a physical device that measures pure logic; we can physically observe something that doesn’t occur in nature.

On the other hand, I’m hesitant to not draw some kind of line between CS and the hard sciences like physics, chemistry, biology, because there seem to be real differences between them. (I was going to point out examples, but realized it’s fundamentally tricky to nail down and I’d be setting a trap for myself. ;)) Yes I agree the philosophy of where CS lands, and what CS really is, does land in the same ambiguous camp as mathematics (probably because CS and math both truly are in the same category of abstract logic, not directly tied to physical observations.) Maybe more useful and abstract tools are more difficult to categorize precisely because they are used as part of all the sciences and arts...

To me, that is not that surprising, although it's a good point.

My view has to do with history of mathematics. People were fascinated with infinities long time before they considered that large but finite systems can be also interesting. I think applications of mathematics, mainly geometry and physics, are responsible too.

The development of more finitist taste in problems (somebody else mentioned the constructivism, which I think is fitting) came with the practical need to do computations and developing algorithms.

So I am not that surprised that one of the early forays into theory of computation are through the lens of infinite, rather than finite.

> Most importantly though, my problem with this kind of discussion is that the question itself is meaningless.

Of course, I forewarned that it's just my view, and you're free to ignore it.

Look, partly why I mention it, it seems rather surprising to me; I would consider infinite structures to be more complicated, in some sense; yet, in the history of mathematics (which lately includes CS, as a study of large but finite), these were studied first. There was nothing that would prevent Ancient Greeks (or Euler) from discovering, say, lambda calculus, or how to do sorting efficiently. Although, it seems in many fields we progress from more complicated to simpler methods, in some way. But I think it's partly precise because the finite is often considered uninteresting by mathematicians, it was overlooked. And that's the philosophical point I am trying to emphasize. Different fields of math perceive (in the way they treat them) the same structures differently, and I gave an example of natural numbers. Another example is the notion of the set cardinality, in most areas of mathematics people only care about countable/uncountable distinction.

I’m with you on skepticism of the x-is-y relationship; however, I read the comment as comparing math versus computing academics.

Then, the so-what answer would be informative for the neophyte or youth who is interested In computing but struggles with mathematics instruction. Right? That’s a real thing in education.

In fact I find this to be the principal benefit of online MOOC courses. You can compare styles of instruction, and pedagogy from major universities from across the US (and internationally).

Another way to put this is that computer science deals with mostly constructive mathematics (more precisely, mathematics that uses intuitionistic logic, the kind that is natural to most programmers and computer scientists anyway). For instance, when you prove the fundamental theorem of arithmetic, you actually can translate that into an algorithm for factorizing numbers into products of powers of primes. And the converse holds too, an algorithm is a proof! If you can give me an algorithm that, given a number n, always produces a prime bigger than n, then that actually witnesses the infinitude of primes.

Constructive methods are everywhere in CS, for instance, to prove a proposition P, it's possible in classical math to say "assume (not P) is true, then derive a contradiction, hence P", however that would be really unnatural in CS! You never hear "I want to show an algorithm to solve P exists, let's suppose it's not computable, ... contradiction!", because you don't end up with an algorithm at all (what you proved instead was that it's impossible for an algorithm to not exist, without saying what it is). Likewise, you if want to show some number/program/data structure has the properties you care about you almost always give the description explicitly.

For more information, I'd say that type theory is a great intersection of math and computer science in a way that's quite accessible to programmers, since we're already used to this kind of thinking, even if we weren't explicitly taught it.

  to show ¬ P, assume P then derive a contradiction (false, ⊥)

OTOH, there's another kind of contradiction proof:

  to show P, assume ¬ P, then derive a contradiction (false, ⊥)

But if we unfold the definition of negation, we have that

  P <-> ((P -> ⊥) -> ⊥)

On that usage, constructivists are happy with all proofs by negation, but not generally happy with proofs by contradiction.

However, a key drawback of this view is that it undersells the linguistic aspect of computer science which is manifested in the search for suitable programming languages.

I think it is justified to regard the design of programming languages as a core area of computer science, and that design space is not finite.

https://news.mit.edu/2020/brain-reading-computer-code-1215

This may indicate that the sampled programmers did not program in the way it can be done for example with declarative languages, i.e., primarily as a linguistic activity where we describe what we know about the task.

I also like the description in Programming as Theory Building by Peter Naur:

https://pages.cs.wisc.edu/~remzi/Naur.pdf

The feasibility of this approach may depend on the programming languages one uses.

In hindsight it's clear that you dont tell a story when you program a computer or not the way I'd describe my day or teach my kids about a phenomenon. It feels more like unrolling a tape and executing a receipe in the most simple way you can after you built a mind model of the machine. You mimic an actor maybe, rather than imagine an event ?

I've met people who view it as mathematics or philosophy or a bunch of other things; in the end, I think there is a wide range of valid mental models for how computers function and therefore how to communicate with them.

There are huge swaths of the field that deal with things like machine learning or distributed systems or computer architecture that don't really fall under that categorization.

When you've disposed of those, read the less well-known paper _Programming as Theory Building_ by Peter Naur (see https://pages.cs.wisc.edu/~remzi/Naur.pdf for a link).

Are there computer science papers that could fit within mathematics? Yes. Are there important computer science papers that clearly don't? Also yes.

Although I will point out, there is https://en.wikipedia.org/wiki/Structured_program_theorem which is a mathematical statement. Whether to actually follow that result when building software is a matter of engineering taste, but the theorem tells you, at the very least, you can do so.

Even if you try to draw a distinction between computer science and software engineering, most of the people writing those papers were pretty squarely on the computer science side.

But I don't draw that distinction. ALL of them were tenured professors of computer science. ALL of them were published in journals of computer science. There is no valid basis on which you can draw an artificial line between computer science and non-computer science, and put those outside of computer science. Doubly not if your goal is to say that computer science is a subset of mathematics rather than its own thing.

I honestly don't see how that follows. Does the fact that writing LAPACK required software engineering mean that numerical linear algebra is not a part of mathematics?

My basis for grouping them together is because of the subjects under study and research methods used. You can always claim that two different fields are different, but I think making arguments for some relationship is more useful.

AS for your example of LAPACK, "The existence of evening, my dear Boswell, does not mean that day is the same as night." Numerical linear algebra is on a boundary between mathematics and computer science. There is a large boundary between math and computer science. But then again the same can be said of, say, math and physics. But by the time you're worried about how to use caching effectively, and make that work in a distributed computation, you're pretty far on the computer science side.

Also your idea of grouping them because of research methods is problematic at best. For example machine learning research has a highly experimental flavor that does not fit in mathematics at all. Quantum computing contains a lot that is closer to a field of applied physics than of mathematics. And so on.

I guess the difference in that regard would be that (software) engineering doesn't necessarily follow the formal scientific method of formulating a hypothesis and then testing it experimentally. That would, in some sense, make it distinct from science. The same would practically apply to many areas in computer science that are studied experimentally, not just software engineering.

To elaborate on that a little, (software) engineering does build on experience and empiricism, as well as analytical thinking, but in practice it may be more in the form of "lessons learned" than in the form of hypothesis testing.

That doesn't make it any less valuable, or even any less valid as an academic area of research. It just, in some sense, makes it possibly distinct from the sciences.

Of course there are also problems in CS that can actually be studied with the scientific method, but I think amelius might have meant that publications such as Dijkstra's and Knuth's papers on goto would be more in the "lessons learned" category than in the "results from the scientific method" category. They would thus not really make computer science a science even though they're not really in the "CS as a part of math" category either.

My position is that computer science is neither a science nor is it a branch of mathematics.

And now I'll contradict the part of what you said about finite structures: At a theoretical level, the field deals with infinite structures, namely the Turing Machine tape and infinite time. We use finite Computing Machines to simulate a finite section of that tape in a finite time.

Maybe we should call it Turing Machine Science, because we use computers to study the behavior of programs in Turing Machines, just as astronomers use telescopes to study the behavior of atoms in stars and particle physicists use particle accelerators to study the behavior of elementary particles. We will never touch those particles, stars, or Turing Machines, but we can know them, hence the science.

Software engineering is like using one's understanding of the emissions of the sun to design better solar panels. Very practical, but you don't use your understanding of gravity-driven fusion reactors every day.

Maybe computer science is about giving, to borrow a little bit from Hilbert, finitary representation to infinitary structures. (Finitary representation with other properties of interest, such as tractability and whatnot, of course.)

Nope. Turing machines are arbitrary and rather unmathematical. The lambda calculus is a much better computational formalism, more mathematically grounded and oriented, with far more direct practical applications.

You can provide formal descriptions for many things - the Perl programming language, for example. I would also call that language unmathematical. You can study such objects mathematically, but they are essentially external objects of study which one is using mathematics to make more tractable.

In contrast, Curry and Howard discovered direct correspondences between logic and lambda calculus. For example, intuitionistic natural deduction is isomorphic to typed lambda calculus. The internal languages of Cartesian closed categories are lambda calculi.

If Church hadn't discovered lambda calculi, they would have eventually been discovered via one of these correspondences.

Wikipedia provides a partial list of these correspondences at https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspon... :

* Girard-Reynolds System F as a common language for both second-order propositional logic and polymorphic lambda calculus

* higher-order logic and Girard's System Fω

* inductive types as algebraic data type

* necessity in modal logic and staged computation

* possibility in modal logic and monadic types for effects

* The λI calculus corresponds to relevant logic.

* The local truth (∇) modality in Grothendieck topology or the equivalent "lax" modality (◯) of Benton, Bierman, and de Paiva (1998) correspond to CL-logic describing "computation types".

As such, lambda calculi are inextricably embedded in mathematics and logic, and their core features (ignoring superficial choices such as syntax) are a discovery, rather than an invention. We can't change the equivalences described above, they are facts that arise from the formalisms developed to address subjects like logic and categorical analysis. The same is not true of Turing machines.

Just because something can be formally and precisely described doesn't necessarily mean it's (aesthetically) "mathematical". Another example that comes to mind now is the notion of an applicative functor (Applicative in Haskell) — sure, you can give the categorical definition for it but it's quite an oddly specific structure (if anyone reading this knows where they arise in non-FP contexts, I'd really like to know!).

So for Turing machines, maybe a question we might ask is, "how can we ensure Turing machines always terminate?" This is a much harder question than say, imposing a type system on untyped lambda calculus which unconditionally makes all terms terminate, while still retaining the ability to do recursion and useful work.

A good yardstick to judge the "mathematicality" of a construction often amounts to looking at its compositional properties. That is, could you re-use the concepts over and over again, and could variants of the structure be uniformly described? While Turing machines and lambda calculus are both equivalent and can be both formally described, one does win over the other in terms of having a simpler, more compositional structure.

This is quite subjective, and in any case it feels remarkable that both Turing and Church came up with their constructions to describe computation formally!

> ... (aesthetically)

The 'aesthetics' part is an interesting argument I didn't see, and yes, I agree that a particular concept arising in different areas of math is 'aesthetically pleasing'.

> ... "mathematical"

That's the part I have a problem with, mathematical objects are (more or less) exactly those that can be precisely and formally described. "Lambda calculus is a more elegant mathematical object" is not a statement I have a problem with, "Turing machines have a lesser status as mathematical entities", on the other hand, is sort of weird.

> So for Turing machines, maybe a question we might ask is, "how can we ensure Turing machines always terminate?" This is a much harder question than say, imposing a type system on untyped lambda calculus which unconditionally makes all terms terminate, while still retaining the ability to do recursion and useful work.

You can bound the number of steps or the size of the tape :) That's not a "well, actually", the point I'm making is that other computational models (TMs, pointer machines, RAMs, counter machines) are more natural formalisms to think about some problems. Sure, logic/proof theory is intimately related to lambda calculi and it would be extremely unnatural to formulate the same ideas using Turing machines, but for things like analysis of algorithms, complexity theory or numerical analysis it would be similarly unnatural to use lambda calculus as the computational model instead.

They certainly aren't lesser forms of math, even though one might find them less aesthetically pleasing.

> ... it feels remarkable that both Turing and Church came up with their constructions to describe computation formally!

It is. It completely blew my mind when I first learned about that fact. If computation can be exactly described by different formalisms resulting in the exact same set of computable functions, then it must be a very fundamental feature of how "things" work!

I agree as well. I don't think Turing machines have any lesser status (it's literally equivalent to lambda calculus, after all!)

> but for things like analysis of algorithms, complexity theory or numerical analysis it would be similarly unnatural to use lambda calculus as the computational model instead.

That's a good point as well. Because of the nature of hardware, neither lambda calculus nor Turing machines are very good fits, so RAMs and pointer machines essentially take over.

"Equivalence" has a specific meaning here, though. The term "Turing tarpit" was invented to point out the limits of that equivalence, and any attempts to define computations for Turing machines quickly run into that.

The sense in which I consider Turing machines to be "rather unmathematical" is closely related to this. You can write useful mathematical proofs in lambda calculus - as I've pointed out elsewhere, there are automated proof assistants based on this fact. There's no such equivalent for Turing machines. Theoretically, there could be, due to Turing equivalence, but in practice, no-one wants to exploit that.

Given one formalism that has actively been used for such mathematical purposes, and another that has been actively avoided, I call the latter rather unmathematical by comparison to the former.

People can quibble with my word choice, but it's describing a real, measurable phenomenon, the effects of which have played out predictably over the last 70 years.

Thank you, this is exactly what I was getting at.

I'd be interested in a source for this.

Lambda calculi are used as the basis for several functional programming languages, which seems to argue against the idea that they're less easy to reason about.

They're also used as the basis for proof assistants such as Coq. Coq is based on the calculus of constructions, which is a typed lambda calculus. Again, this would be a mystifying choice if lambda calculi are difficult to reason about.

> I disagree with your statement that it is more mathematically grounded.

I've provided more support for my position here: https://news.ycombinator.com/item?id=27334163

https://plato.stanford.edu/entries/church-turing/

"In his review of Turing’s work, Church himself acknowledged the superiority of Turing’s analysis of effectiveness, saying:

computability by a Turing machine … has the advantage of making the identification with effectiveness in the ordinary (not explicitly defined) sense evident immediately. (Church 1937a: 43)"

Moreover, Gödel himself (as well as other mathematicians) found Turing machines and Turing's thesis to be more persuasive:

Gödel also found Turing’s analysis superior. Kleene related that Gödel was unpersuaded by Church’s thesis until he saw Turing’s formulation:

According to a November 29, 1935, letter from Church to me, Gödel “regarded as thoroughly unsatisfactory” Church’s proposal to use λ-definability as a definition of effective calculability. … It seems that only after Turing’s formulation appeared did Gödel accept Church’s thesis. (Kleene 1981: 59, 61)

Gödel described Turing’s analysis of computability as “most satisfactory” and “correct … beyond any doubt” (Gödel 1951: 304 and *193?: 168)."

For what it's worth, I do think you've started an interesting discussion!

You're allowed to have an opinion that you prefer lambda calculus over LCMs (logical computing machines -- a better term for Turing machine's that Turing favoured) for conceptualizing and reasoning about computation mathematically.

Myself, I find Conway's game of life to be the superior framework over both lambda calculus and Turing's Logical Computing Machine :-P

However, those quotes are not saying "that Turing machines are a more elegant basis for computations, since they are much easier to mathematically reason about." I still consider that statement to be false, and I've substantiated that in my comments.

The quotes from Church and Gödel are saying that Turing's formalism was the more helpful in making the case that it had captured the notion of effective calculability. That's understandable - it's much like e.g. Cantor's diagonal, in that it makes its subject very concrete.

But that doesn't tell us anything about the usability of the formalism as an actual mechanism for computation, or analysis of computation. In that respect, lambda calculus has proved far more useful, as shown by the examples I mentioned, and many more. Another example is denotational semantics, which maps programming language semantics to lambda calculus.

In fact, one of the inventors of denotational semantics, Dana Scott, developed the first non-trivial model of the lambda calculus, in terms of complete lattices. That model addressed the concreteness issue, albeit decades later, in the early 1970s. It's possible Gödel, Church etc. might still have preferred the Turing tape as an intuition-friendly proof for effective calculability, but it would no longer be possible to reasonably make Gödel's "thoroughly unsatisfactory" claim about the lambda calculus.

Coming back to denotational semantics, I'm pretty sure no-one has ever provided a non-trivial language semantics in terms of a Turing machine - and if you wanted to do that, one of the easiest ways to do it would probably be to implement a compiler from lambda calculus to Turing tape, and generate the Turing representation automatically from that.

More generally, my position could be simply refuted with counterexamples of tractable Turing machine solutions to any of the various problems that lambda calculus has been used to address, like programming language implementations, programming language semantics, duals of logical systems, and proof assistants. To my knowledge, no such examples exist, and the reason for that is because what I'm saying is a fact, not an opinion.

> Myself, I find Conway's game of life to be the superior framework over both lambda calculus and Turing's Logical Computing Machine :-P

I'll agree that the game of life is only slightly less useful than the Turing machine as a model of computation!

This is what I primarily meant with my controversial statement, sorry I didn’t articulate it well enough. Of course lambda calculus is very useful and has plenty of applications, never meant to say otherwise!

I also agree that the absence of such a refutation is a pretty solid argument that your position is simply a fact and not an opinion as I argued.

Cheers friend!

For seeing whether a given statement holds true, minimizing complexity is the most important.

Precisely, and that's the main difference between computer science and the rest of mathematics.

Typically CS cares about the process to find a result, and not just its value nor the possibility or impossibility to find it.

Typically, programmers care about the process to find the result. Some programmers are computer scientists. You can not conclude that all computer scientists are programmers, so your statement is based on logical fallacy.

There are results in theoretical computer science that don't care about the efficiency in the process; the most essential are the computability theorems exploring what parts of mathematics can be computed, and what we mean by computation anyway.

But the most essential part -the halting problem- was resolved long ago, so the lion's share of applications of computing science is in finding practical ways to use computers, which again needs to take efficiency into account.

Efficiency and tractability of representation is also an issue, though, and mathematicians (and programmers) do care about that, a great deal. That's why the lambda calculus has been used as the basis for proof assistants such as Coq, whereas Turing machines have not.

Sometimes that could mean using the lambda calculus, particularly in study of language theory and type systems. Other times that could mean some sort of black box model, such as when proving lower bounds for solving problems using specific operations (see e.g. the sorting lower bound). Yet other times, like when establishing the ground-zero of some new variety of computational hardness, I can't think of many more suitable models to cut up into pieces and embed into the substrate of some other problem than those based upon Turing machines.

My original comment certainly reads that way, but my intent was really to point out that it doesn't make sense to privilege the Turing machine model in the study of computation. I wrote more about why in this comment: https://news.ycombinator.com/item?id=27334163

As I said above, it may very well be that the best usage for Turing machines is using them in mathematical proofs; where the efficiency of the computation is not a concern.

This response might come off as a little facetious, but seriously, I think the idea of "founding" industrial computing languages/platforms upon theoretical research models of computation misunderstands the relationship between theory and practice. There is a relationship for sure, the research on these models usually does want to translate into real-world implications somehow, but your functional programming language is not the literal lambda calculus.

Each time a new theoretical model is created to represent a particular programming problem, entirely new languages are created to ease the practical approaches of building systems for the underlying problem.

And it is worth keeping track of which models are good for which problems. So no, theoretical models are not good just for doing math with them, also for guiding practical usage.

That was a claim someone made, but it turned out to be a misunderstanding, and is incorrect.

I've covered this here: https://news.ycombinator.com/item?id=27338055 (see the parent comment for quotes from Godel & Church that I'm referring to.)

Thus proving the point that a field that studies them cannot be considered a branch of mathematics.

[1]: https://en.wikipedia.org/wiki/Monster_group

Thus defining the Monster group is discrete mathematics, but not computer science (or not directly). Finding parts of the Monster groups that can be represented and manipulated by computers would be computer science.

Subject boundaries are arbitrary, but they have a practical implementation in terms of university CS departments.

Some CS departments came out of math departments, and some universities have a "Department of Mathematics and Computer Science. The theoretical side of CS does seem like a branch of mathematics.

Other CS departments came out of EE departments, and and some universities (MIT, Berkeley) have a "Department of Electrical Engineering and Computer Science." The practical side of CS does seem like a branch of engineering.

A number of stand-alone CS departments (Stanford) still seem to be part of the school of engineering, so my vote is for CS as an engineering discipline with a theoretical basis in mathematics (perhaps like information systems or signal processing.) I also like the idea of Caltech's "Computing and Mathematical Sciences," as it seems to bring a lot of computing and applied math under one roof.

This subsumes finite structures, parseable Problem descriptions, structured formulas, formalized algorithms, etc.

John Kemeny majored in mathematics and taught “Finite Mathematics” while a professor. He saw the application of BASIC not as a new field but as a way to simplify computers so that it wasn’t only mathematicians and scientists who could program them.

I tend to think that basic (though probably something like Python/numpy rather than BASIC proper) programming fits well into many math courses. The fact that modern TI calculators can run Python seems to mesh nicely with this. (And classic calculators with BASIC also have a long history.)

Math courses often in introduce algorithms for arithmetic and algebraic computation, so some coverage of algorithms as a concept seems to fit as well.

> BASIC not as a new field but as a way to simplify computers so that it wasn’t only mathematicians and scientists who could program them.

This is a fantastic vision. Of course mathematicians and scientists also benefit from user-friendly languages like BASIC or Python. But the idea that computer programming (and computing in general) could be helpful to undergraduates majoring in humanities and social sciences, and perhaps to the public at large, was probably still a fairly radical idea in the 1960s! Trying to make that happen by creating a programming language that first-year students could learn in an afternoon (or so) was/is a remarkable step toward making that vision real.

It's not always clear what is computer science and what isn't. For example, you can find both mathematicians and computer scientists in theoretical computer science. In bioinformatics, you often see similar work from people with CS and life sciences backgrounds.

However, there's a general and unified way to define anything computing-related, unifying both traditions: seeing computer science as studying the automatic processing of symbols. I.e., anything that the human mind treats as a symbol with a meaning, that can be represented in physical devices and transformed in a different set of symbols through mechanized processes.

This definition widens the scope of comp.sci beyond its origins in representing calculations of physics and maths, to include other fields typically taught in the degree but that people don't think of as computer science: natural language processing, design of viable user interfaces (human-computer interaction), design of adequate programming languages apt for different problems.

The most general view of this definition encompasses disciplines far removed from engineering, but which are nonetheless used to expand its frontiers: aristotelian ontology was used to invent object-oriented programming, and is still used to explore the semantic web; or semiotics to explore what ideas can be represented and processed automatically, and the best way to build user interfaces tailored to the way we think.

The Wikipedia article for "Computer Science" has relevant information, quote (some line breaks added):

  In the early days of computing, a number of terms for the practitioners of the field of computing were suggested in the Communications of the ACM—turingineer, turologist, flow-charts-man, applied meta-mathematician, and applied epistemologist. Three months later in the same journal, comptologist was suggested, followed next year by hypologist. The term computics has also been suggested.

  In Europe, terms derived from contracted translations of the expression "automatic information" (e.g. "informazione automatica" in Italian) or "information and mathematics" are often used, e.g. informatique (French), Informatik (German), informatica (Italian, Dutch), informática (Spanish, Portuguese), informatika (Slavic languages and Hungarian) or pliroforiki (πληροφορική, which means informatics) in Greek.

  Similar words have also been adopted in the UK (as in the School of Informatics of the University of Edinburgh). "In the U.S., however, informatics is linked with applied computing, or computing in the context of another domain."

Since Bologna, it got levelled to Masters, but most still take the 3 + 2 years, not to be left behind the older generation that had 5 + 2 for Master.

So plenty of time to go down into the subjects that USA consider computer science.

However for those that want to really go down the rabbit hole of computer science as seen on USA, the appropriate degree is Applied Maths into Computing.

Somewhat similarly, I have a degree in number theory / modal logic systems that was issued by the philosophy department at my university. The concepts are similar to a CS degree except you get really good at describing the problem because philosophy degrees usually involve a lot of writing.

Nowadays it's just an antiquated term for programmer. The average C programmer if wager is above 40 years of age whereas the average python or web dev dev must be pushing late 20s.

For example: Computer vision, machine learning, data science, cryptography, etc are all rife with infinite objects! Proof assistant software and SMT solvers can also prove things about infinite mathematical structures from number theory, ZFC, topology, etc.

Pure mathematics also cares about finite algorithms. Every proof is a finite sequence of deductions on finite objects from a countable set... eg a computer program! Other examples include: computing bounds, integrals, roots of polynomials, divisors, bases, fundamental groups, etc. Pure math is full of computation!

tl;dr the line between math and cs is extremely fuzzy.

Avoiding computer science directly... Geophysics is a "telescope science." A typical geophysicist sees themselves as experts in seismic interpretation, the tool they use. When the subject turns to the actual subject (the earth), they call it geology, or rock physics. It's not an idealistic take, or a very scientific one, but it's apparently useful to their work.

To take the reductio ad absurdum head on, I don't think it's totally useless to think of astronomy or microbiology as telescope or microscope sciences. It certainly introduces biases, but it might also remove certain biases and lead to new ways of phrasing a question. It might lead to new lines of inquiry, and is somewhat descriptive of how these fields developed historically. Wasn't Astronomy Astrology, before it was telescope science?

You could go with an intentionally provocative "computer science is not about mathematics" or "not about science."

What if we were to phrase Dijkstra's statement as a question: "Is computer science about computers?" It's not a statement you can approach with empirical falsification. That doesn't mean it's false, or useless. It just means you can't treat it like you would F=ma.

This is why I've been quite happy with the Information Science major. I joke that it's "watered down compsi", as it avoids higher level topics like OS design and anything beyond the introductory Data Structures. Instead, the major uses that time to introduce psychology, sociology, and user experience/interface design. As a professional, I've found that focus on "how we interact and best use technology" to be useful.

That would be leaning in to the "telescope science" analogy.

In graduate school, I attended another large top-ten research university and again, no courses on programming language theory. The reason being all the PL faculty had either recently been poached by industry or accepted positions at more prestigious universities.

The result was that my entire computing education felt like watching shadows on the wall of Plato's cave; I was never exposed to fundamental concepts like lambda calculus or to non-standard languages like Haskell or Lisp that might have given a different perspective on computing.

Only recently in the past 1-2 years have I started to fill in the gaps myself, but I can't help but feel cheated. It's pretty crazy that the research-level faculty turnover can prevent thousands of students from being exposed to such an important aspect of computing.

(imagine, for instance, if an entire class of engineers had no option to take a course on heat transfer simply because there was no research faculty available who specialized in heat transfer research)

This is a non-sequitor. Google hires a lot of PL PhDs (I'm one of them). And for relevant teams there is a "Domain Expertise" portion of the interview. And many of the people working on the languages and frameworks you mention have such background.

You don't like these systems. That's fine. But "Google would do it all differently if they just hired some PL PhDs" is just false.

[0]:https://talks.golang.org/2012/splash.article

Just as assembly gives as close to a "bare metal" view of hardware as many of us will ever come, languages like Haskell and Lisp give a "bare metal" view of CS theory.

I accidentally stumbled onto Haskell in my masters course. On the first day at university I attended a trial class of functional programming[1] course and instantly liked the way professor taught. However, I didn't take the course then and forgot all about it. The next semester I took compilers course and approached that professor for my masters thesis. During a meeting he gave me couple of options one of which was in functional programming domain. This time I took the plunge and went all in. Took the FP course and the professor who taught FP became my thesis advisor. The next two years were the most intense and intellectually satisfying years of my life. Not only did I learn Haskell but also built a compiler for it. I still get goosebumps remembering the rollercoaster ride I had in those two years.

During all that, the book by SPJ [2] became my constant companion. The book was actually out of print but my advisor had a book that was signed by SPJ himself :-). And I promptly photocopied it so I have it with me even to this day.

Suffice to say Haskell, lambda calculus along with SPJ and my advisor have had a lasting (and continue to) influence my life.

[1] https://www.cse.iitb.ac.in/~as/fpcourse/fpcourse.html

[2] https://www.microsoft.com/en-us/research/wp-content/uploads/...

Dan Grossman has a great set of courses on Coursera, and a good number of resources are in those discussion boards.

https://www.coursera.org/learn/programming-languages

For practice; I highly recommend learning Haskell. If you are new to functional programming then learning Haskell is challenging and frustrating but as with any new topic the key is to not give up but keep probing. A good recent development is lot of mainstream languages are beginning to include functional paradigms such as lambda, closures etc., For example Java introduced lambda expressions, Javascript has had them for a while now. But from a first-principles stand point Haskell is as good as it gets so please do learn and code in Haskell if not at work then at least side projects.

For theory I've found following material super useful.

0. This[0] is an incredibly awesome lecture where Phil Wadler takes us on a whirlwind tour of computer science. He talks us through different foundational structures on which almost everything (hardware and software) about computer science is built. I watch this lecture once every few months :-). It helps you build up context and ground various topics.

1. The one and only SICP. Book[1] and lectures[2].

2. Automata theory[3]. This isn't an easy course but gets to the heart of the matter i.e., the meaning of "function" and what how can it be mechanically "computed".

3. Category Theory is where lot of active research is happening in CS theory. This is a very good lecture series[4]. The pace may seem a bit meandering but don't be put off. Bartosz is a gifted teacher and works incredibly hard to disseminate knowledge. For evidence just look at a recent post on HN[5] about an article he published.

[0] https://www.youtube.com/watch?v=aeRVdYN6fE8

[1] https://mitpress.mit.edu/sites/default/files/sicp/full-text/...

[2] https://www.youtube.com/watch?v=-J_xL4IGhJA&list=PLE18841CAB...

[3] http://ce.sharif.edu/courses/94-95/1/ce414-2/resources/root/...

[4] https://www.youtube.com/watch?v=I8LbkfSSR58&list=PLbgaMIhjbm...

[5] https://news.ycombinator.com/item?id=26991300

Ignore this part because the one I referred to is a different person! Though they are both terrific :-)

https://haskell.mooc.fi

Not me, but a friend described a whole team of engineers at his company hired to put out the fires caused by using database software that is a poor fit for the application, rather than biting the bullet and either 1) performing a migration or 2) rolling their own solution.

> [...] informatique (French), Informatik (German), informatica (Italian, Dutch), informática (Spanish, Portuguese), informatika (Slavic languages and Hungarian) or pliroforiki (πληροφορική, which means informatics) in Greek. Similar words have also been adopted in the UK (as in the School of Informatics of the University of Edinburgh). In the U.S., however, informatics is linked with applied computing, or computing in the context of another domain. [1]

[1] https://en.wikipedia.org/wiki/Computer_science#Etymology

Or if, say, you have issues delivering something on time to a client (no matter the domain), you can always invoke a "bug informatique".

So "informatique" means and is used, at least in french, much, much, much more than just "computer science".

In a way it's even worse than in english: at least "science" is added to "computer" in english and it's kinda self-explanatory. In french everything is in the same basket: from someone doing its Ph.D. to someone having a lesson to learn how to use the mouse... It's all "informatique".

- Students learning to use MS Office in school? Informatik.

- People fixing printers and replacing your harddrive? Informatik.

- System administrators managing a datacenter? Informatik.

- Data scientist applying deep learning techiques? Informatik.

- University professor trying to prove P==NP? Informatik.

Honestly, I envy the Americans for their destinction between "computer science" (CS) and "information technology" (IT). Even if computer science is not really about computers.

Even a common programmer does not use any actual "computer science" 99% of the time and your typical sysadmin type probably never knew any. So it's simply wrong and confusing to use the same word for it.

* "tieto": knowledge but also sometimes information or even data. Computer is "tietokone", knowledge machine (IMO "tieto" one of the worst words in Finnish due to the too broad scope which is why we also say "informaatio" and "data" these days)

* "käsittely": processing or handling

* "tiede": science

I don't think the "ics" in Informatics comes from "mathematics". It is more general: Aesthetics, Economics, Genetics, Linguistics, Physics, Statistics. It just means "the study of".

That same suffix, -atica, is also applied in "the mathematic" as the person (-atic) and "The Mathematics" as the science (el Matemático, las Matemáticas).

So lets say that you are a guy from two centuries ago. Someone tells you "this guy has studied informatics, he is the Informatic of the town". That would sound as if he "is versed in the study of information" rather than Computing.

Also, in Spain, instead of "the Computer" (the thing that computes, calculates), they call it "the Order-ator" (Ordenador, the thing that brings order).

Ordenar has two meanings in Spanish:

- To command someone

- To sort

Both are related. In order to sort some set, you need order. And rules. Thus, "ordenador" has a lot of sense.

But if I was some guy from the 50's I'd translate computer science as "informática electrónica". (Electronic Informatics).

But you are right that as a job description, “informatikus” is a more basic position than “programozó”=developer/software engineer, etc.

Instead, more commonly seen are 情報工学 ("information engineering") or 情報科学 ("information science") - which is equivalent in meaning to "informatics".

[1] There was even a significant attempt in 2000 to change the name of KAIST [2] CS department from "전산학" to "컴퓨터 과학" or similar. The attempt was unsuccessful and to this day its name remains "전산학(부)". Prof. Kwanggeun Yi has written a public letter [3] against the change.

[2] https://www.kaist.ac.kr/en/

[3] http://ropas.snu.ac.kr/~kwang/memo/name.html

But I agree, the European phrases are more honest to the content.

The fatal error in computer science was that it modeled complex systems without truly understanding them. Computers simulated complexity. You might know more or less what was likely to happen. But the causes remained unclear."

- Bruce Sterling, Zenith Angle

I think this part is backwards, and I would even say that CS is about complexity itself. In some ways it is even meta-mathematical even though it is a subset of mathematics.

There is an interesting paper measuring the complexity of different things in terms of a minimal Turing machine (sorry, I’m not sure about the details but will try to find it) and it gave a relatively small number for the complexity of the base axiom set of modern maths (few kb, or maybe MB?) It really put it in perspective for me what is mathematically provable and all the rest of things that we don’t even have the tools to reason about, at most we can compute it.

https://www.youtube.com/watch?v=7EA-eVWEIKY

Also, people arguably use the scientific method when programming. I think that Sedgewick illustrates this point well in Algorithms: https://algs4.cs.princeton.edu/14analysis/

I saw this happen with my Math Teacher Hero and with common teachers.

Computer science has existed for thousands of years, the naming has just been a bit off.

https://www.cs.utexas.edu/users/EWD/ewd10xx/EWD1036.PDF

If he means the informal proofs mathematicians write and publish all day long, these actually include a lot of handwaving, metaphors, generalizations, and leaps of logic that the reader is presumed to be expert enough to fill-in-the-blanks. So for example, Wiles had a non-trivial bug in his proof of Fermat's last theorem that was thankfully non-fatal and fixable.

On the other hand, if Dijkstra was referring to formal proof, then without a proof assistant one still easily makes mistakes in it, and even with a proof assistant the task is so immensely tedious even now that even mathematicians don't do it, so why would programmers of non-safety-critical apps?[1] And another blind spot is that no formal proof will help you if your specification is wrong, and only give you false confidence: you can't navigate the world without errors if the only geometry you know is Euclidean.

[1]: of course, note that many people are trying to develop good enough proof assistants that mathematicians would feel add more value than remove via tedium. And also note that formal methods are being employed when the stakes are high enough; e.g. formal verification is performed on processor circuits.

The general response seems to be that "yeah, ideally we should be more mathematically rigorous with programs if we have time and mathematical expertise", but few have sufficient exposure to formal methods to understand that it's far from the panacea the memo makes it out to be and there are more reasons not to do it than just time and expertise.

For example, he suggests that we need to understand computer science as a "radical novelty" and stop applying inapt analogies that come from thinking about this like a gradual evolution of mechanical things.

Inapt mechanical metaphors include software "tools" and "workbenches" that require "maintenance". Getting stuck with bad industrial analogies is "medieval thinking" that prevents real understanding.

> it gives us a clear indication where to locate computing science on the world map of intellectual disciplines: in the direction of formal mathematics and applied logic, but ultimately far beyond where those are now, for computing science is interested in effective use of formal methods and on a much, much larger scale than we have witnessed so far.

I'm not too interested in arguing point-by-point the other arguments for viewing them as a "radical novelty", but even mathematics deal in methods that require maintenance (e.g. calculus -> analysis), and half of it is coming up with the correct definitions (metaphors). Is it all that medieval? (Ironically, the medievalist recognizes that logic made great progress in that era, then took a break in the Renaissance until Frege and friends)

Example: my wife likes to put gym shorts and shirts in different drawers. To my CS mind that doubles the seek time of a retrieval.

The little bowl by the door is a cache of my most recently used stuff.

People who nearly file their papers (eg bills) nearly are optimizing for retrieval efficiency - of an operation that is actually very rare.

When my wife and I leave the apartment we often take the garbage out to the chute. My wife likes to drop off the garbage before pressing the button to to call the elevator. To me that's weird because calling the elevator is long running IO in a separate thread - might as well start it asap.

Oh, man. I've felt exactly the same way wrt. a lot of IRL scenarios, implicitly optimizing the number of "threads" I can do tasks in, for instance:

- starting an automated but lengthy task (e.g. choosing Nixpkgs PRs to automatically review) before going out for a period of time

- starting the microwave heating food before going to the toilet

- pressing the elevator button before tying my shoes (in a private elevator scenario)

Distinct from multitasking, which splits your attention, here, you can still dedicate attention to a task at hand while knowing in the background that a thread is running. These types of behaviors may not really do all that much long term, but it sure feels nice you optimize IRL scenarios.

It maybe rare but that fact doesn't capture the probability that the importance of retrieval could be disproportionately high - when you really need that bill, you definitely want it and want it quick.

Seems very unlikely & it's a very improbable event and if it does happen, say you have "all your bills for the last 3 years" jumbled up together it'll take a minute or two to find it anyway. Vs filing each one carefully..

However, after getting a CS degree and building things at work....I get upset a lot. I see so many things that are unoptimized and get angry when I have to wait because the process is bad.

I refuse to do things without proper tools, as I don't want to fiddle with something for hours while a proper tool can achieve a desired result in minutes.

Now, that I think about this it has been affecting me greatly.

Excerpt from http://i.stanford.edu/pub/cstr/reports/cs/tr/65/26/CS-TR-65-...:

> I consider computer science to be the art and science of exploiting automatic digital computers, and of creating the technology necessary to understand their use. It deals with such related problems as the design of better machines using known components, the design and implementation of adequate software systems for communication between man and machine, and the design and analysis of methods of representing information by abstract symbols and of processes for manipulating these symbols. Computer science must also concern itself with such theoretical subjects supporting this technology as information theory, the logic of the finitely constructable, numerical mathematical analysis, and the psychology of problem solving. Naturally, these theoretical subjects are shared by computer science with such disciplines as philosophy, mathematics, and psychology.

That is actually underselling telescopes and microscopes. It was telescopes that really gave us modern astronomy. Before we had the ability to really observe stars and planets, we were stuck with a very simplistic, geocentric view of the universe. The telescope was what really opened up venues for us to really understand astronomy.

Similarly, before the invention of the microscope, we had a very limited understanding of biology. There was no germ theory of disease, instead just theories about 4 humors. It was the microscope that really opened up venues for us to really understand biology. In fact, we even have a branch of the science that is basically dedicated to the biology of stuff you see under a microscope - microbiology.

With astronomy and biology, the science, such as it was, preceded the invention of the tools that were really needed to study it. With computer science, people were not capable of doing calculations fast enough to really appreciate complexity theory and asymptotes. At low N, N^2 and 2^N can look similar (4^2 == 2^4). The computer both became the application for computer science, as well as revealed the need for this area of study.

One can almost imagine an analogy, where the stars are invisible to the naked eye. Someone invents a telescope, and all of a sudden discovers the full wonders of stars. There is a pretty good chance that astronomy in that world might be called something like "telescope science" since the telescope is so intrinsically linked both to the birth of the area of study as well as its application.

https://mobile.twitter.com/sydgibs/status/138740846208320307...

(not true in general but still insightful)

> I've never liked the term "computer science." The main reason I don't like it is that there's no such thing. Computer science is a grab bag of tenuously related areas thrown together by an accident of history, like Yugoslavia. At one end you have people who are really mathematicians, but call what they're doing computer science so they can get DARPA grants. In the middle you have people working on something like the natural history of computers-- studying the behavior of algorithms for routing data through networks, for example. And then at the other extreme you have the hackers, who are trying to write interesting software, and for whom computers are just a medium of expression, as concrete is for architects or paint for painters. It's as if mathematicians, physicists, and architects all had to be in the same department.

http://www.paulgraham.com/hp.html

And yes, astronomy is pretty much about looking at the shadows of sticks under the sun; and this includes more complex "sticks" like telescopes.

1. Math-heavy "CS" that studies algorithms.

2. The study of teams and best practices, maybe "Computer Sociology"

3. The study of tech team and company efficiency, maybe under psychology.

4. Computer Engineering, the study of how to engineer computers

5. The hypothetical science behind that engineering, the science not of algorithms, but of structure and design of computers themselves

So they cargo cult CS into a sort of weird pure/applied-ish math hybrid full of contingent generalisations like Big O and debatable abstraction traditions - not least the idea of provability, which only applies to conceptually self-contained micro-problems and is a much harder sell for big complex systems.

The engineering track - including the theory of how to design systems so they actually work, are easy to use, and are maintainable - is underrepresented.

https://www.youtube.com/watch?v=-J_xL4IGhJA&list=PLE18841CAB...

Not sure about the year.

[1]: http://www.naur.com/comp/c4-3.html [2]: http://www.naur.com/comp/c4-4.html

I think the US degrees are more focused on practicality than the Danish version. Basically the Danish universities will teach basic programming in one or two languages and the expect you to be smart enough to figure out the rest.

It’s not that one education is better than the other, but given that I didn’t end up doing reasearch of heavy computational work, I might have preferred a US education.

So the way to call yourself a software engineer without a math-education is to move to a country like US, making even the "Software Engineer"-title problematic.

Also, isn’t it easiest to think of a computer as an abstract concept that could both represent a physical device and the abstract computer? Computation needs a computer, whether real or abstract.

Lastly, I think science is the more “wrong” word in the name.

Coincidentally, in my native tongue, we regularly don't use "calculus" as a term for mathematical analysis any more than we use "computer science" for informatics.

I’m not sure which of his books I read it in..

He called it datalogy, the science of the nature and the use of data.

See Peter Naur: “The Science of Datalogy”, Communications of the ACM, July 1966.

https://dl.acm.org/doi/10.1145/365719.366510

Incidentally, he became the first professor of datalogy in Denmark at the University of Copenhagen, founding DIKU, the Institute of Datalogy.

Maybe Computology would be a better name..

Turing's universal machine is the original dependency inversion of our field: instead of specifically studying the programs that can be written for any particular hardware device, we largely study phenomena that are regarded as computation as defined by the Church-Turing thesis, and require that the hardware vendors supply suitable universal machines which can instantiate the phenomena of our study. Or field is the science of computers -- every program is a blueprint for a computational device -- but we choose to simulate most of our blueprints using universal machines, so that we don't have to send each one off to the silicon fab separately.

This is one of the few cases in which I think the Brazilian Portuguese translation is way better. It actually conveys a more precise idea of what the discipline is about.

I’m envious of those who have had the opportunity to study computer science and earn a recognised degree for that investment.

I’m self educated and continuously study computer science. It is the one specific subject that I long to study full-time around similar thinking individuals.

I’m fortunate to have had a successful career as a software engineer, but that’s just not enough for me. I aspire to apply my mind for reasons other then a salary.

Examples:

"I Have Never Killed Any One, But I Have Read Some Obituary Notices with Great Satisfaction" (Darrow, not Twain, https://quoteinvestigator.com/2011/05/05/darrow-obituary/)

"When the Facts Change, I Change My Mind. What Do You Do, Sir?" (maybe not Keynes, https://quoteinvestigator.com/2011/07/22/keynes-change-mind/)

"A Lie Can Travel Halfway Around the World While the Truth Is Putting On Its Shoes" (neither Twain nor Churchill, https://quoteinvestigator.com/2014/07/13/truth/)

"Everybody is a Genius. But If You Judge a Fish by Its Ability to Climb a Tree, It Will Live Its Whole Life Believing that It is Stupid" (not Einstein... https://quoteinvestigator.com/2013/04/06/fish-climb/)

"I Disapprove of What You Say, But I Will Defend to the Death Your Right to Say It" (not Voltaire, https://quoteinvestigator.com/2015/06/01/defend-say/)

When you realise the fundamentals are loops, data, comparisons, addition, negative numbers and instructions of those then computer science is building logical structures based on said computational primitives.

You can check it here: https://www.youtube.com/watch?v=2Op3QLzMgSY

Abelson in the first minute crosses both computer AND science, and references the also legendary SICP with "computer so-called science actually has a lot in common with magic".

Honestly, this alone already made the article that empty.

In particular, the computer programs we typically develop are designed to automate some process that a human would have otherwise done. We can study those processes -- and spaces of such processes -- independently of the executive agent that ultimately performs those processes.

Sure, there are some formulas in economics, but 99.99% of the time you are not going to prove anything mathematically and you are just looking up a formula written by somebody else. On the other hand economics has a huge amount of stuff that is not covered by mathematics at all.

It is disheartening to see so many people wasting so much of their potential by studying CS when they know they will get into software development anyway. Rather than racking education costs they could be earning money and gaining experience.

I have been constantly hiring for the past 15 years and I have learned to stop caring about CS. Real world experience is worth more than comparable time spent studying CS.

The only reason I may prefer a candidate with a degree is because it takes a lot of work and perseverance to stick to the goal of earning the degree, but I almost don't care what kind of technical degree you have earned.

One more point, it is not like academia is the only place where you can learn CS! In some areas of knowledge and at bleeding edge of it you may need access to people, but basic CS knowledge that can ever be even potentially useful at development work is all well documented in a huge selection of very good books.

You can pick them up and learn.

Good developers treat learning as part of their work, and it doesn't matter if something was not taught at school -- if they notice they are missing some knowledge they will just learn it.

If you need to study something I think it is better to study something orthogonal to what you are going to be doing. This can help create unique profile for you as a developer.

For example I have studied theoretical math and over the years I came to conclusion that was much better choice than going to CS. I have learned logical thinking and dealing with complex abstract problems. I have learned most of the CS stuff anyway while doing my work but I would probably never learn most of what I learned in math.

Other good directions of studies would be philosophy, visual arts, management, accounting -- you see the picture. Any of these could provide you with an edge as a developer for particular set of problems.

Even if you go somewhere like Google you will find most of their systems are just REST APIs as described above.

Now, there obviously is a lot of interesting projects for you compiler or OS lovers. But there is so much choice you don't have to be ready to work on them. I mean, I don't need to learn robotics just because 0.2% (entirely made up number) of projects on job market are about writing software to control robots.

So, to sum up:

-- if you are in it for money, don't waste time on studying CS, just learn basic programming and hop on any project.

-- learn on your employers time. How fun it is being paid and learning?

-- you don't need to get every job. You only need to get one (every three years...)

-- most projects are boring from the point of view of programming techniques you are going to be using. Learn to find fun somewhere else.

-- if you want fun projects you can always learn what you need on your own (on your or your employers time). You aren't going to be good developer if you don't spend considerable amount of time learning for the rest of your life, anyway. Just get used to spending time learning new stuff every day.

It does not matter much how good your technical skills are if other force multipliers are very low.

More than that, people who are bad at communicating and relations tend to stay away from these problems -- trying to bring every problem to technical level -- basically ensuring they are continuing to be at a disadvantage.

I learned about making Operating Systems, Compilers, 3D Graphics, Artificial Intelligence, Machine Learning, TCP/IP Networking, Databases, low-level Assembly programming, and how computers work at a hardware logic gate level, to name a few. And they offered other courses as well, these are just what I picked from the offerings.

Yeah, there was the standard Data Structures and Algorithms class (which in the business world is now not much more than a 'you better know/refresh this if you want to get through our interviews' class) and one class that was about Automata theory, which my teacher would claim 'is the only real computer science class at this school' which was all mathematical proofs, but it still helps you understand regular expressions better, at least it did for me.

But most of the classes I took would have had practical applications in the workforce, for different types of jobs. But really isn't that pretty much any undergraduate major? The classes you take aren't all going to be directly relevant to your particular path through the field, it's more about exposure to different possibilities and providing a broad base of knowledge to build from.

The best I can come up with is ‘instruction science’ the study of how to structure, execute and store sequences of instructions. The computer is a tool to do it faster, but you can also use pen and paper, it would just take longer.

It combines the focus on the process in computer science / computing with the focus on the data in datalogy / informatics. It tells that the process is what we are really interested in. At the same time, it admits that the data and the results are what ultimately matters and that computation is just an irrelevant side effect we would like to avoid.

https://youtu.be/-J_xL4IGhJA?list=PLE18841CABEA24090

It'd be nice if there was a better division between the blackboard purists and the pointer-slingers, but in most cases they have been lumped together, and it produces a subpar education for both breeds.

In contrast, many schools nowadays are moving away from computing concepts towards teaching students how to use Microsoft Office, which troubles me greatly.

The analogies that this argument hinges on are often brought up in a dogmatic manner with historic terms jeered in euphoric tone.

In threads like these devil's advocates, normally copious, are scant. Why?

There is an uncanny valley between non-science and science. Realistically, everything we know about a lot of things exists in that uncanny valley. Most or all of psychology & economics. A lot of of zoology, ecology, health sciences etc. Yet, it's an uncomfortable place.

Different professions have dealt with it differently over time, usually trying to reach one bank or the other.

The bad name pseudoscience has isn't unearnearned. Our modern conception of "scientific" (empirical falsification, etc.) was kinda invented to debunk turn of the century psychology and economics... and those often did earn pseudoscience's reputation.

The philosophical implications of "hard" sciences really are different, and the disadvantages of semi-scientific pursuits do really manifest.

Say we study mental health impacts of exercise on teenagers. You may find a result in one school. It might be replicable in a nearby school. It probably won't hold true in a different country or a decade. That's because we aren't really isolating fundamentals, as scientists should. OTOH, we can't isolate fundamentals in a lab and still have results that are relevant to actual mental health IRL. Does that mean the whole pursuit is pseudoscience?

Computer science is in the same position. You can strive for an F=ma, ideal understanding of fundamentals... but... there's not always a lot of gas in that car.

But even so, it would better be called “computation science”.

It is called “informatica” in Dutch, in any case.

  Computer Science ~ physicists
  Computer Engineering ~ electrical engineers
  Computer Technician ~ electricians

Computers today are surely then just applied computer science.

Odd thing is I don't see a bunch of bookkeepers brandishing anything.

Anywhere else CS is called „Informatics“, meaning the science to do with information.

Broad enough to make articles like this unnecessary.

Someone that does abstract computation is a Computer. It was a profession

No need to get confused on how we got here