Computer "science" isn't

A good number of programmers, at least the ones that actually care about what they do and aren't just code grinders, like to fancy themselves scientists and mathematicians; that they're uncovering universal truths about computation, and that everything stupid we've done is simply a result of the youth of our field. But in practical reality, programming isn't math or science, but rather engineering. We're not working with universal abstract machines; we're working with more or less specific hardware with more less specific properties, which is itself almost certainly running more or less specific software that you're expected to interact with. What is optimal code on a 90s game console is very different from optimal code on a modern high-end PC, and that itself is very different from optimal code on a 2010s smartphone. Even beyond that, a lot of what we consider fundamental to programming is dependent on a specific kind of digital computer. Instead of collections and associative arrays, we speak of linked lists and hashmaps, things that are contingent on memory addresses and pointers. This isn't to say that there are absolutely no universal truths in programming, but they were mostly figured out before modern computers became widespread, were in many cases inherited from math and logic, and are grandly uninteresting, not in the least to the soothsayers of universal truths in computer science, who are much more interested in talking about cache management and SIMD instructions. This is not to say that it's wrong to focus on things like cache management and SIMD instructions, but we shouldn't delude ourselves into thinking that we're doing something more than we are.

So so your point is nit picking the terminology here? I'd say that research in computational maths, cybersec and AI are valid fields at least. And the universal truth of computer science being that anything which can be used as a logics gate can also be used as a computer. And while biologists are ostensibly scientists, they often find themselves specializing on a particular type of arthropod or genus instead of an universal truth either, aside of some shared concepts within the discipline, like Darwinian natural selection with some modern twists like Epigenetics. Your time might have been better spent naming your variables instead of making this thread.

ITT: OP rediscovers Abelson On more serious note, this is purely cultural thing OP. Here in Yurop we call this thing Informatics. A science about information, still malformed, but a tiny bit better than abstract Computer Science. Anyway, you talk about semantics, why?

Your point being what? Anyway I find myself interested in both ends of the spectrum, from some of the higher level design principles to the low level implementation on specific architectures. Then again design isn't science, I hope you're not putting a lot of hope in the ""science"" part of computer science. It's not newtonian physics if that's what you're looking for. On the other hand, you could read SICM.

>>43219 algorithm design is pure mathematics, as is designing good hashes, cryptography, machine learning, computer vision,... research jobs are much rarer than codemonkey jobs but the field itself incorporates applied mathematics.

>>43219 What I believe you are getting at is that sciences are concerned with real existing systems. If CS was a science, then it would be the only one concerned with purely man-made systems. Mathematics would not be an exception, as it is a totally different discipline. Computer science is not concerned with natural phenomena and cannot have the same philosophy applied, so it must not be a true science. I agree with this. Who would disagree though? From the student gunning to be a fagman slave, to lambda afficionados, would any person stand up for the assertion that computer science is a science? Even at the university level, this is reflected in the fact that we have different computing departments, so computer science is literally not a branch of science. Similarly, there are courses called 'software engineering' which are not part of the engineering department. Neither are held to the rigor of the branches they purport to be part of. The name 'computer science' is an accident, an awkward name we keep because we don't know what else to call it. Really it should be just called 'computing' so it may stand as it's own discipline with it's own rules. It would be better still if it were considered a branch of engineering and held to the same rigor. This won't happen because universities don't want to filter the massive amounts of CS students they get, who just want the paper to get a job working on unimportant digital products.

>>43227 We might as well go after the "social sciences" next. Many of the papers that are produced there do not even compare with the rigor and reproducibility of something like the "aerodynamics of anime titties". But if we really want to go with something else then computing is even worse, since not only does it now obscure the distinction between the science and engineering part but now also could be confused with the job of a 19th century abacus pusher. The only obvious alternative was already mentioned here but it might be a good idea to prefix that with theoretical vs. applied informatics. One of the rare Ws for the Euros. And with that the thread might as well get locked now since the only other topic left is why OP felt the need to make this thread.

Computer science is to computers as physics is to physical reality - they're misleading BS explanations mixed with a little truth.

>>43229 Discrete subjects are a spook anyway. It's all connected and everything in the universe computes. Present day.

>>43228 I made the thread because I get annoyed seeing people overintellectualize what is, in material reality, a trade, not an art, let alone a science. People will go on long rants about how such and such methodology for everything bad and that we should instead all be using such and such other methodology for everything. >You shouldn't be doing OO, you should be doing functional! >You shouldn't be doing functional, you should be doing procedural! >You shouldn't be doing procedural, you should be doing OO! It's so goddamn exhausting. The correct answer is whatever works best for the problem at hand. I've used a million different approaches using a million different tools, because I care about actually solving problems, not forming insider trades online.

>>43236 don't bother with them? I mean, if it's in your workplace, then is like kicking dead whales down the beach to be you, but then again why vent here (won't change a thing). If on the internet, then don't bother.

>>43236 I agree, from the practical side it's all just different tools for different jobs. To play devil's advocate there also is a notable research side to it too like making physics simulations more accurate and performant or how to get that tesselation shizzle ma sizzle over at Stanford U. And I also think most CS degrees really don't even care what the S even stands for. But you know what really grinds my gears? Those fairies who want me to use mimi bites and bibi bytes and pipi bytes. I mean imagine getting stockholm syndromed so hard by storage hardware manufacturers and their sales departments so hard for so long that you decide to just roll over and decide to speak like a damn infant and want others to follow suit! But duurrrrr, it's not a scientific unit! Kilo, mega and giga are in decimal! (soils pants) Listen here, you weak chinned early birth, 1024 is 2 by the power of 10, that's decimal enough for me in this context and counting bytes in anything by in power of 2s is some soft fontanelle level soykaf! I'm already getting made fun of for choosing such a soy latte career, at least let me have some terminology that doesn't make me sound more like an imbecile when I use IT jargon around people from other departments! But nooo, I've seen these cunts gleefully boast how they'd passive aggressively provide wrong UI output on purpose where it tells the user something is 3,2MB even though it's actually 3.2 million bytes just so that they can be "scientifically accurate"! They should be glad the good guys lost and we ain't using ternary with Teslas vertex math or it would make their feeble minds explode! How I despise those spineless cowards!

Over this summer I have been working with circuit simulation software and wanted to see what can I create if I start from scratch. You first express the functionality that you want to implement (addition, subtraction, division, multiplication, bit shift) in boolean algebra, convert the boolean expression into a truth table, derive the Karnaugh map on that truth table, and implement the logic (addition in this case) using logic gates (AND, OR, NOT, XOR, NOR, etc.). You end up with an addition module built exclusively with transistors. Repeat for other desired functionality. Take a very simple 8-bit processor as an example. What you need is a form of encoding (use the first two bits for opcode, rest for data along the 8-bit input), a control unit that will recognize opcodes, an arithmetic logic unit that will contain logic modules (addition, subtraction, multiplication, division, bit shift), and 8 LEDs which will light up in sequence to signal the result. You can go further and expand the module with registers built out of flip-flops for storing data, clock signal sources for synchronizing registers with the processing unit (comprised of control unit and arithmetic logic unit), a feedback loop that operates over the data repeatedly, external interrupts, and more sophisticated output mechanisms (such as a 64x16 array of LEDs as a display). At the end of the summer I had a 16-bit microprocessor that could run a very narrow subset of assembly instructions and had a user interactive I/O mechanism. I don't think this had any less merit than synthesizing some molecules in a chemistry lab. Now, I have started dabbling in Rust recently and I have no idea how any of this works. For instance, take the following code fn main(){ println!("Hello world!"); } This is the simplest program you can write in Rust. Yet I have now idea how it **actually** works. I think I know how microprocessors work in general, but I have no idea about what the Rust compiler actually does with this code, which instructions does it call, how does that run on my laptop's processor, how that is displayed on the screen. I am now acutely aware how little I know about how my computer actually works. The complexity is so abstracted way that using my computer now feels like enchanting spells to make things happen. I suspect that this is why computer science isn't seen as a science. It doesn't **feel** like science. It feels like you are whispering spells to a rock that goes vroom and makes things appear on your screen but there is actual logic behind it. You don't need to bother with, mostly, and focus on leveraging that power to write software, which itself might be considered scientific work or an invention if you create something truly novel.

>>43237 By trade, I write C++, and my experience with C++ is that it attracts highly opinionated midwits who think they've seen the face of God because they know what a SIMD instruction is. By hobby, I write Haskell, which has the exact opposite problem, where many of its users disdane thinking about the actual machines that their code will be running on, despite the language itself making quite a few compromises in order to be capable of doing so. >>43240 My main point is that, in the real world, we're dealing with the concrete and contextual, not the abstract and the universal. The hardware is always a variable, every abstraction atop that just adds more variables, and real world programs are shaped by practical concerns rather than what is theoretically optimal anyway.

> ITT: I want to say something about computer science but I never read a single research paper

>>43240 Consider looking at lisps and forth if you want to understand how it all works. When using an unprincipled language that makes the language designer special you aren't going to implement the features you see yourself nor how it works. However in forth you can make your own compiler for it and see how the base one works see Jones forth for example https://github.com/nornagon/jonesforth/blob/master/jonesforth.S For lisps I'd recommend even common lisp, it's a big language but how the system works is also isn't too magical and the disassemble function allows you to see the assembly generated. Every abstraction you see you could write yourself (control flow, pattern matching, object systems) . There is of course machinery of the implementation but you can see precisely what that is by macro expansion and seeing what it calls (how functions are stored and works). Smalltalk is fairly similar In this degree These are of course more opaque than forth, but it's easy enough to see how it all works and implement yourself

>>43244 > When using an unprincipled language that makes the language designer special you aren't going to implement the features you see yourself nor how it works. Having macros or an exotic stack-based threaded metaprogramming facility is not going to make you understand lexing->parsing->ast pipeline, constant folding, linking, etc, because most of this either doesn't exist in those languages, or is hidden from user in the same way as in statically compiled ones. Doing a basic compiler engineering course would be more helpful to understand how things work. Lisp and Forth are more useful on a more abstract level of deeper understanding linguistic and control flow abstractions, etc.

Over here it's not called computer science, instead it's "informatics". Seems like the distinction is lacking in english speaking countries.

>>43245 > Having macros or an exotic stack-based threaded metaprogramming facility is not going to make you understand lexing->parsing->ast pipeline, constant folding, linking, etc, because most of this either doesn't exist in those languages, or is hidden from user in the same way as in statically compiled ones Huh, the reader in these languages are simple. The Jones forth link I sent shows it, and is something the user can implement the colon (:) word itself. For common lisp the reader is hackable and the reader (i.e. The parser), is something you can modify and understand as just another component. At which point you are at the ast as the syntax you are writing is the ast you are hacking on in lisp. It is very open to the user For constant folding i don't believe sbcl offers this but it does let you setup custom assembly instructions in the actual compiler via vop to have it work with Also what do you mean by statically compiled languages? Do you mean a batch compiler? When I teach computer science we quickly go over how read works then do some basic recursion before getting into a metacircular interpreter. At which point you understand how it all works. They are a good basis for understanding how languages work at a deep level which is the benefit that the user is confused about

>>43219 Computer science itself is a science, or at least a branch of math. Software engineering is just applied computer science. The amount of computer science being applied depends on the sub-field of computer science. >Writing high performance computing algorithm libraries? Heavily computer science >Writing a website frontend? Less so computer science, but knowing computer science will make you better at your job

>>43248 https://github.com/numcl/constantfold

>>43248 > Huh, the reader in these languages are simple. They asked about how Rust program works, using a language that compiles and works in a different way by skipping a lot of things Rust compiler does or doing them differently is not going to help them to understand how Rust compiles and works. > For constant folding i don't believe sbcl offers this but it does let you setup custom assembly instructions in the actual compiler via vop to have it work with Ofc sbcl does it, it's a highly optimized compiler that's been going for decades, the point is: you don't even know about it, because it's happening behind the scenes just like with languages like C++ or Rust. > Also what do you mean by statically compiled languages? Do you mean a batch compiler? I mean languages with complex grammars, and overall the classic pipeline of lexing -> parsing -> ast analysis, type inference and type checks, optimizations and transformations, full-program linking/inlining/optimizations, etc. In those languages you suggest, the boundaries between lexing and parsing are muddied and the boundaries between code and data are muddied, and even the boundary between compile-time and runtime is muddied, because in both Common Lisp and Forth you can just go on and continue programming in the runtime of your program as the full compiler is a part of runtime of every program. AST strictly speaking doesn't even exist, because in Lisp it's just the same cons-cells as usual, and in Forth it's all "words" or howerer they call it. This is all great for metaprogramming but this is also extremely different from how basically every other programming language in existence works.

>>43252 >>43240 Mentions > I suspect that this is why computer science isn't seen as a science. It doesn't **feel** like science. It feels like you are whispering spells to a rock that goes vroom and makes things appear on your screen but there is actual logic behind it. You don't need to bother with, mostly, and focus on leveraging that power to write software, which itself might be considered scientific work or an invention if you create something truly novel. In which using a language like lisp or forth would ease his issues here. It isn't as simple as the chips he's been working on, but the foundation is there to do interesting things to get the understanding to a somewhat similar level. There is always the classic pipeline of assembly into forth into lisp into prolog to understand the generation of languages and abstractions. As to answer > I mean languages with complex grammars, and overall the classic pipeline of lexing -> parsing -> ast analysis, type inference and type checks, optimizations and transformations, full-program linking/inlining/optimizations, The parsing is the least interesting thing and can be picked up quite easily with parser combinators and isn't more interesting than just learn how to write a simple read as the process is the same, get some text and read it into the ast. One can infer the overcimplicated version from doing the simple one.

At School I was average at maths yet amazing at english. 24 now, Am I still able to get into programming? , I can read code written in Ruby and Python , it makes sense to me yet everyone says I need to be good at math. I can write .sh scripts in Linux, I think anyone and their pet monkey can do that though.

>>43259 You can get into programming even at 40, even if your past career was unloading trucks at a store. But landing a job in programming in that situation is much harder—you’ll likely need to present yourself as having at least a few years of experience, otherwise ngmi.

>>43259 >yet everyone says I need to be good at math. These people are likely misleading you in order to hold you back. You don't need to be good at math. You might pick up some math as you learn, you may even get good at math. But you don't need much a priori mathematical knowledge or maturity. Particularly, standard mathematical education would take you into calculus and analysis, which for some reason makes people think they need calculus for programming, even though there isn't the slightest trace of continuity (in the sense of real analysis) in computers. Lineal algebra, abstract algebra, number theory, those are all a lot more relevant but in no way are they prerequisites. A good mathematician tends to make a good programmer, and also the other way around, but at any rate programming is a good way to learn mathematics rather than the other way around. I'm 34 and, though I learned to program at about your age, I am relearning, in a way, because I took a long hiatus an then shifted paradigms completely and I am picking it up as if I were a beginner (with some background knowledge I already got about computers and plenty of linux experience). My point is don't fall for the decreasing neuroplasticity meme. If you don't actually make the effort to learn something new at such a young age as 24, only then will your ability to learn would deteriorate. >I can write .sh scripts in Linux, I think anyone and their pet monkey can do that though not really. Also, as time passes, more and more people offload that knowledge to LLMs and become unable to write 10 lines of code by themselves. If you avoid that, in a year you'll be better than an increasing number of vibemonkeys.

The entire field of programming, computer science, and software engineering is so different to anything that has come before. Yet for different people at different times it shares a lot of similarities with engineering, science, trades, and generic clerical work like accounting, making it difficult to definitely categorize. I'm not even sure how helpful categorizing it would be. Categorizations of course are not universal truths either, they're merely semantic conveniences we use to make communication easier. Where does the river end and the sea begin? The truth is there is no river and there is no sea, just as there is no science and there is no engineering. But we overlook this truth for the sake of convenience. Would setting aside truth and getting everyone to agree on the category that programming falls under improve any of our lives? I don't think so. In fact, people who have tried to do this have only opened themselves up to criticism and debate. If you do it for money, call it a profession. If you do it for fun, call it a hobby. I wouldn't worry about what it is. Just whatever it is, keep getting better at it.