14 ms·

Computer science courses that don't exist, but should (2015)

• journal 1y ago
  We can take a further step back and say that no one really knows how to do pagination and those who do are sick of it to teach it to others.
• fred_is_fred 1y ago
  The Classical Software Studies would be quite useful. Go write a game in 64kb of RAM in BASIC. It would really stretch your creativity and coding skills.
  • asyncze 1y ago
    [dead]
  • jasonthorsness 1y ago
    Agreed, it would be very interesting to see some of the care taken for resource management that is lost now because every machine has “enough” RAM and cycles…
    • andoando 1y ago
      There's generally courses on embedded
  • corysama 1y ago
    I’m e long thought the Gameboy Advance would make a great educational platform. Literally every aspect of the hardware is memory mapped. Just stuff values into structs at hard-coded addresses and stuff happens. No need for any OS or any API at all.
    • deleted 1y ago
      [deleted]
    • markus_zhang 1y ago
      Yeah I think a CompArch class on Gameboy would be pretty interesting. But only as an introductory course because students need to learn other advanced concepts that Gameboy does not have.
  • lmm 1y ago
    I think working on that kind of system would be actively harmful for most programmers. It would give them a totally unbalanced intuition for what the appropriate tradeoff between memory consumption and other attributes (maintainability, defect rate, ...) is. If anything, programmers should learn on the kind of machine that will be typical for most of their career - which probably means starting with a giant supercomputing cluster to match what's going to be in everyone's pocket in 20 years' time.
  • bruce511 1y ago
    Ha. You call it "history". I call it "childhood". I did that years before getting to Uni :) Although, to be fair, while it was a helpful practice at coding, I'm not a game designer, so it was a game too terrible to play. First year Uni though I spent too many hours in the lab, competing with friends, to recreate arcade games on the PC. Skipping the game design part was helpful. To be fair by then we had a glorious 640k of ram. Some Assembly required.
  • tdeck 1y ago
    Bonus points if it fits in 38911 bytes.
• epalm 1y ago
  Where’s the course on managing your reaction when the client starts moving the goal posts on a project that you didn’t specify well enough (or at all), because you’re a young eager developer without any scars yet?
  • dfex 1y ago
    some scars need to be earned
  • ekidd 1y ago
    Back in the 90s, this was actually a sneaky part of Dartmouth's CS23 Software Engineering course. At least half your grade came from a 5-person group software project which took half a semester. The groups were chosen for you, of course. The professors had a habit of sending out an email one week before the due date (right before finals week) which contained several updates to the spec. It was a surprisingly effective course. (Dartmouth also followed this up with a theory course that often required writing about 10 pages of proofs per week. I guess they wanted a balance of practice and theory, which isn't the worst way to teach CS.)
    • collingreen 1y ago
      In uni we had a semester long group project with the stronger coders as project leaders. Group leaders controlled pass/fail for the group members and vice versa. After the leaders put together project plans for their teams and everyone was supposed to start working WHOOPSIE reorg and all the leaders got put on random teams and new people got "promoted" into leader (of groups they didn't create the plan for). If the project didn't work at the end the entire group failed. I've never been taught anything more clearly than the lessons from that class.
    • markus_zhang 1y ago
      Shit I was thinking about exactly the same thing: professor deliberately change requirements at last week to mess up the students and give them a bit of taste of true work. Glad that someone actually did this.
  • 1y ago
• mnky9800n 1y ago
  I am happy to sign up for all these classes. Tbh this is what coursera or whatever should be. Not yet another machine learning set of lectures with notebooks you click run on.
• pluto_modadic 1y ago
  "when you need shiny tech (you don't)" (aka, when to use postgres/sqlite)
• LPisGood 1y ago
  It is interesting that no software engineering or computer science course I’ve seen has ever spent any time on CI/CD. Jenkins, Docker, Kubernetes, none of these sorts of things - and I don’t even mean these specific technologies, but moreover nothing even in their ballpark.
  • hotstickyballs 1y ago
    Personally it felt quite natural once you start to work on real software projects.
    • LPisGood 1y ago
      I have never felt that way, and I’ve worked on a variety of projects at a variety of companies. Everyone has a bespoke mishmash of nonsense pipelines, build tools, side cars, load balancers, Terragrunt, Terraform, Tofu, Serverless, Helm charts, etc. There are enough interesting things here that you wouldn’t even need to make a tool heavy project style software engineering course - you could legitimately make a real life computer science course that studies the algorithms and patterns and things used.
      • bckr 1y ago
        Merging strategies, conflict resolution, bisect debugging, and version control in general are very computer sciencey. Would make a great course.
        • LPisGood 1y ago
          That’s not even getting into the fact that you could basically teach multiple graduate level distributed computing courses with k8s as a case study
  • andoando 1y ago
    Well this has nothing to do with computer science so there's that
• corysama 1y ago
  > CSCI 3300: Classical Software Studies Alan Kay, my favorite curmudgeon, spent decades trying to remind us we keep reinventing concepts that were worked out in the late 70s and he’s disappointed we’ve been running in circles ever since. He’s still disappointed because very few programmers are ever introduced to the history of computer science in the way that artists study the history of art or philosophers the history of philosophy.
  • pathseeker 1y ago
    programmers are introduced to CS history, it's just mostly irrelevant or poorly contextualized so there are no useful lessons
  • PaulDavisThe1st 1y ago
    The history of art or philosophy spans millenia. The effective history of computing spans a lifetime or three. There's no sense comparing the two. In the year 2500 it might make sense to be disappointed that people don't compare current computational practices with things done in 2100 or even 1970, but right now, to call what we have "history" does a disservice to the broad meaning of that term. Another issue: art and philosophy have very limited or zero dependence on a material substrate. Computation has overwhelming dependence on the performance of its physical substrate (by various metrics, including but not limited to: cpu speed, memory size, persistent storage size, persistent storage speed, network bandwidth, network scope, display size, display resolution, input device characteristics, sensory modalities accessibly via digital to analog conversion, ...). To assert that the way problems were solved in 1970 obviously has dramatic lessons for how to solve them in 2025 seems to me to completely miss what we're actually doing with computers.
    • degamad 1y ago
      > art [has] very limited or zero dependence on a material substrate This seems to fundamentally underestimate the nature of most artforms.
    • degamad 1y ago
      > To assert that the way problems were solved in 1970 obviously has dramatic lessons for how to solve them in 2025 seems to me to completely miss what we're actually doing with computers. True they might not all be "dramatic lessons" for us, but to ignore them and assume that they hold no lessons for us is also a tragic waste of resources and hard-won knowledge.
• d_silin 1y ago
  "CSCI 4020: Writing Fast Code in Slow Languages" does exist, at least in the book form. Teach algorithmic complexity theory in slowest possible language like VB or Ruby. Then demonstrate how O(N) in Ruby trumps O(N^2) in C++.
  • d_silin 1y ago
    The book in question: https://www.amazon.ca/Visual-Basic-Algorithms-Ready-Run/dp/047113418X https://www.amazon.ca/Visual-Basic-Algorithms-Ready-Run/dp/0...
  • LPisGood 1y ago
    Python has come along way. It’s never gonna win for something like high-frequency trading, but it will be super competitive in areas you wouldn’t expect.
    • pjmlp 1y ago
      It could be much better if most folks used PyPy instead of CPython as favourite implementation.
    • dominicrose 1y ago
      The Python interpreter and core library is mostly C code, right? Even a Python library can be coded in C. If you want to sort an array for example, it will cost more in Python because it's sorting python objects, but it's coded in C.
  • liqilin1567 1y ago
    Optimizing at the algorithmic and architectural level rather than relying on language speed
  • nine_k 1y ago
    One of my childhood books compared bubble sort implemented in FORTRAN and running on a Cray-1 and quicksort implemented in BASIC and running on TRS-80. The BASIC implementation started to outrun the supercomputer at some surprisingly pedestrian array sizes. I was properly impressed.
• andrewmcwatters 1y ago
  [dead]
• ggm 1y ago
  Ls and not cat? Does the author have no memory of cat -v shitstorm?
  • PennRobotics 1y ago
    ls and not mpv or ffmpeg? https://mpv.io/manual/stable/#options https://mpv.io/manual/stable/#options https://ffmpeg.org/ffmpeg.html#Options https://ffmpeg.org/ffmpeg.html#Options
• abdullahkhalids 1y ago
  The TFA wants the following computer science courses: Unlearning Object-Oriented Programming: a course on specific software engineering techniques Classical Software Studies: a course on the history of software tools Writing Fast Code in Slow Languages: a course on specific engineering techniques User Experience of Command Line Tools: an engineering design course Obsessions of the Programmer Mind: course about engineering conventions and tools. One day, the name of science will not be so besmirched.
  • LPisGood 1y ago
    People don’t get this up in arms when there is a math course about using math tools or math history or how math is used to solve actual problems, but for some reason they do about computer science.
    • abdullahkhalids 1y ago
      If universities offered a major in which students learned to operate telescopes of various kinds and sizes, and then called it astrophysics, people would be mad too.
      • LPisGood 1y ago
        Astronomy isn’t about telescopes yet astronomers spend lots of time studying and doing research regarding telescopes.
    • owlbite 1y ago
      They just label such people as Applied Mathematicians, or worse: Physicists and Engineers; and then get back to sensible business such as algebraic geometry, complex analysis and group theory.
• TZubiri 1y ago
  >CSCI 2100: Unlearning Object-Oriented Programming Discover how to create and use variables that aren't inside of an object hierarchy. Learn about "functions," which are like methods but more generally useful. Prerequisite: Any course that used the term "abstract base class." This is just a common meme that often comes from ignorance, or a strawman of what OOP is. >CSCI 4020: Writing Fast Code in Slow Languages Analyze performance at a high level, writing interpreted Python that matches or beats typical C++ code while being less fragile and more fun to work with. I like this one, but see? Python is heavily OOP, everything is an object in python for example. I'm wondering if OP took a basic OOP course or would otherwise be interested in taking one? You can learn about a thing you are against, or even form your opinion after actually learning about it. >
  • Bigpet 1y ago
    > Python is heavily OOP, everything is an object in python for example. I strongly disagree. How is everything being called an object in any way "heavily OOP"? OOP is not just "I organize my stuff into objects". You can write OOP code with python but most python code I've seen is not organized around OOP principles.
    • TZubiri 1y ago
      >I strongly disagree. How is everything being called an object in any way "heavily OOP Do I need to spell it out? The O in OOP stands for object.Everything is an object therefore it is Object Oriented. It's not much more complex than that man. And I don't mean that it supports users writing oop code, I mean that the lang, interpreter and library are themselves written with oop. Inheritance? Check. Classes? Check. Objects? Check. Even classes are an object of type MetaClass.
• kelseyfrog 1y ago
  CSCI 4810: The Refusal Lab Simulate increasingly unethical product requests and deadlines. The only way to pass is to refuse and justify your refusal with professional standards.
  • LPisGood 1y ago
    CSCI 4812: The Career Lab Watch as peers increasingly overpromise and accept unethical product requests and deadlines and leave you high, mighty, and picking up the scraps as they move on to the next thing.
    • andrewflnr 1y ago
      Conventional university degrees already contain practical examples of the principles of both these courses in the form of cheating and the social dynamics around it.
  • jayd16 1y ago
    Actually a lot of degrees have a relevant ethics class.
    • kelseyfrog 1y ago
      I don't disagree that such classes exist, but I have yet to see an ethics lab specifically with the intention of practicing refusal.
      • jayd16 1y ago
        Hmm I seem to remember considering the ethics of contracting for the military, for example, but not in a mock sprint planning, if that's what you mean.
    • tsumnia 1y ago
      Unfortunately "ethics" can also be a sneaky way to insert "politics" into the curriculum.
• username223 1y ago
  I had forgotten about prog21, and I'm impressed how he wrapped up his blog: > I don't think of myself as a programmer. I write code, and I often enjoy it when I do, but that term programmer is both limiting and distracting. I don't want to program for its own sake, not being interested in the overall experience of what I'm creating. If I start thinking too much about programming as a distinct entity then I lose sight of that. Programming is a useful skill, even in the age of large language models, but it should always be used to achieve some greater goal than just writing programs.
• markus_zhang 1y ago
  > CSCI 3300: Classical Software Studies Discuss and dissect historically significant products, including VisiCalc, AppleWorks, Robot Odyssey, Zork, and MacPaint. Emphases are on user interface and creativity fostered by hardware limitations. Definitely would love that. Reading source code is pretty hard for newbies like me. Some guidance is appreciated.
• zzo38computer 1y ago
  I think it would be a good idea, especially CSCI 3300. (Learning them in a course is not the only way to learn computer and other stuff, but is (and should be) one way to do.) (However, CSCI 2100 shouldn't be necessary if you should learn stuff other than OOP the first time, even if you also learn OOP.)
  • a1studmuffin 1y ago
    I really don't understand the modern hate towards OOP. From my experience over the last few decades working with large C and C++ codebases, the former turns into a big ball of mud first.
    • zzo38computer 1y ago
      I think that OOP can be good for some things, but that does not mean that all or most programs should use OOP for all or most things. I would say that for most things it is not helpful, even though sometimes it is helpful.
    • BlackFly 1y ago
      Most hate of OOP comes from the definition that OOP = inheritance. Meanwhile, among people that consider themselves OO programmers, there is often the same revulsion towards inheritance and a preference for encapsulation while still calling that OOP. Because each language is subtly different, these things tend to flame war. Which of course people do and why of course you have: > PSYC 4410: Obsessions of the Programmer Mind
• omosubi 1y ago
  I would add debugging as a course. Maybe they should teach this but how to dive deep into figuring out how to learn the root cause of defects and various tools would have been enormously helpful for me. Perhaps this already exists
  • 9dev 1y ago
    Yes please. Even senior engineers apply with their debugging abilities limited to sprinkling print-exit over the code. Do you have a moment to talk about our saviour, Lord interactive debugging?
    • AnimalMuppet 1y ago
      Interactive debugging tends to be unhelpful on anything realtime. By the time you look at what's going on, all the timing constraints are shot and everything is broken. You may be able to see the current state of that thread at that moment, but you can't move forward from there. (Unless you freeze all the threads - but then, all the threads involved might not be in one process, or even on one machine.)
    • joquarky 1y ago
      Sometimes logs are the only way. It's old but reliable.
      • 9dev 1y ago
        I’m not negating that. But in most cases, using a debugger is the vastly superior way to debug issues, yet many developers have never bothered to pick up on that knowledge. Like a carpenter that hasn’t ever learned to work with power tools and insists to use manual screwdrivers for everything.
  • lexicality 1y ago
    Along with a course on how to read other people's code and how to resist the urge to tear down Chesterton's fence while you fix bugs
  • 1y ago
• a-dub 1y ago
  > CSCI 2100: Unlearning Object-Oriented Programming but 90s fashion is all the rage these days!
• ugh123 1y ago
  Not really "computer science" topics, but useful nonetheless.
• zdc1 1y ago
  > PSYC 4410: Obsessions of the Programmer Mind I was definitely guilty of this in my last role. Some of my refactorings were good and needed, but also a distraction from saying the codebase was "good enough" and focusing on the broader people/team/process problems around me.
• raldi 1y ago
  CSCI 4083: Developing Software Alongside Other Human Beings
• gonzo41 1y ago
  CSCI 2170: User Experience of Command Line Tools. This should exist and the class should study openssl.
  • dapperdrake 1y ago
    You are so cryptic.
• tomhow 1y ago
  Previously: Computer science courses that don't exist, but should (2015) - https://news.ycombinator.com/item?id=16127508 https://news.ycombinator.com/item?id=16127508 - Jan 2018 (4 comments) Computer science courses that don't exist, but should (2015) - https://news.ycombinator.com/item?id=13424320 https://news.ycombinator.com/item?id=13424320 - Jan 2017 (1 comment) Computer science courses that don't exist, but should - https://news.ycombinator.com/item?id=10201611 https://news.ycombinator.com/item?id=10201611 - Sept 2015 (247 comments)
• casey2 1y ago
  ls should have just been for listing files, giving it 10 flags is one of the big mistakes of early UNIX design
• aryehof 1y ago
  CS102 Big Balls of Mud: Data buckets, functions, modules and namespaces CS103 Methodologies: Advanced Hack at it ‘till it Works CS103 History: Fashion, Buzzwords and Reinvention CS104 AI teaches Software Architecture (CS103 prerequisite)
  • owlbite 1y ago
    Introduction to PhD study: "How hard can it be, I'm sure I could write that in a week"
• 0xbadcafebee 1y ago
  Jesus christ Yes to all of it. Also needed: Systems Engineering 101/201/301/401: How to design a computer system to be reliable Security Engineering 101/201/301/401: How security flaws happen and how to prevent them Conway's Law 101/201: Why the quality of the software you write is less important than your org chart The Real DevOps 101/201/301: Why and how to simultaneously deliver software faster, with higher quality, and fewer bugs Old And Busted 101/201: The antiquated patterns developers still use, why they're crap, what to use instead Thinking Outside the Box 101: Stupid modern designs and why older ones are better New Technology 101: The new designs that are actually superior and why Project Management 101/201/301: History of project management trends, and how to manage any kind of work Managing for Engineers 101/201/301: Why and how to stop trying to do everything, empowering your staff, data-driven continuous improvement Quality Control 101/201: Improving and maintaining quality Legal Bullshit 101/201: When you are legally responsible and how not to step in it
  • stoneman24 1y ago
    In addition, Team Dynamics 301: A course in Blame Management Handling the traditional “innocent punished, guilty escape/promoted” issue. With explanation of the meme “Success has 100 fathers/mothers while failure is a orphan.
• rippeltippel 1y ago
  CSCI 4321: Unlearning Vibe Coding
  • waynesonfire 1y ago
    CS4322: Introduction to RTFM
• tdeck 1y ago
  > User Experience of Command Line Tools Is this a good place to complain about tools with long option names that only accept a single dash? I'm thinking of you, `java -jar`.
  • lexicality 1y ago
    every single go program
• DeathArrow 1y ago
  I propose CSCI 3500: Software Engineering is Not About Writing Code
• DeathArrow 1y ago
  Also CSCI 3600: Making Optimal Compromises in Software Development
• ninetyninenine 1y ago
  Unlearning object oriented programming I think OOP became popular because it feels profound when you first grasp it. There is that euphoric moment when all the abstractions suddenly interlock, when inheritance, polymorphism, and encapsulation seem to dance together in perfect logic. It feels like you have entered a secret order of thinkers who understand something hidden. Each design pattern becomes a small enlightenment, a moment of realization that the system is clever in ways that ordinary code is not. But if you step back far enough, the brilliance starts to look like ornament. Many of these patterns exist only to patch over the cracks in the paradigm itself. OOP is not a natural way of thinking, but a habit of thinking that bends reality into classes and hierarchies whether or not they belong there. It is not that OOP is wrong, but that it makes you mistake complexity for depth. Then you encounter functional programming, and the same transformation begins again. It feels mind expanding at first, with the purity of immutable data, the beauty of composability, and the comfort of mathematical certainty. You trade one set of rituals for another: monads instead of patterns, recursion instead of loops, composition instead of inheritance. You feel that familiar rush of clarity, the sense that you have seen through the surface and reached the essence. But this time the shift cuts deeper. The difference between the two paradigms is not just structural but philosophical. OOP organizes the world by binding behavior to state. A method belongs to an object, and that object carries with it an evolving identity. Once a method mutates state, it becomes tied to that state and to everything else that mutates it. The entire program becomes a web of hidden dependencies where touching one corner ripples through the whole. Over time you code yourself into a wall. Refactoring stops being a creative act and turns into damage control. Functional programming severs that chain. It refuses to bind behavior to mutable state. Statelessness is its quiet revolution. It means that a function’s meaning depends only on its inputs and outputs. Nothing else. Such a function is predictable, transparent, and portable. It can be lifted out of one context and placed into another without consequence. The function becomes the fundamental atom of computation, the smallest truly modular unit in existence. That changes everything. In functional programming, you stop thinking in terms of objects with responsibilities and start thinking in terms of transformations that can be freely composed. The program stops feeling like a fortress of interlocking rooms and begins to feel like a box of Lego bricks. Each function is a block, self-contained, perfectly shaped, designed to fit with others in infinitely many ways. You do not construct monoliths; you compose arrangements. When you need to change something, you do not tear down the wall. You simply reassemble the bricks into new forms. This is the heart of functional nirvana: the dream of a codebase that can be reorganized endlessly without decay. Where every part is both independent and harmonious, where change feels like play instead of repair. Most programmers spend their careers trying to reach that state, that perfect organization where everything fits together, but OOP leads them into walls that cannot move. Functional programming leads them into open space, where everything can move. Reality will always be mutable, but the beauty of functional programming is that it isolates that mutability at the edges. The pure core remains untouched, composed of functions that never lie and never change. Inside that core, every function is both a truth and a tool, as interchangeable as Lego bricks and as stable as mathematics. So when we ask which paradigm handles complexity better, the answer becomes clear. OOP hides complexity behind walls. Functional programming dissolves it into parts so small and transparent that complexity itself becomes optional. The goal is not purity for its own sake, but freedom; the freedom to recompose, reorganize, and rethink without fear of collapse. That is the real enlightenment: when your code stops feeling like a structure you maintain and starts feeling like a universe you can endlessly reshape.
• EigenLord 1y ago
  I wish more comp sci curricula would sprinkle in more general courses in logic and especially 20th century analytic philosophy. Analytic philosophy is insanely relevant to many computer science topics especially AI.
• beardyw 1y ago
  > It's about being able to implement your ideas. No, it's about creating something which does something useful and is easy to maintain. Plumbers have great ideas and approaches but you just want plumbing which works and can be fixed . It's time developers realised they are plumbers not **** artists. [HN reduced my expletive to just four asterisks which seems a bit reductionist]
  • rkomorn 1y ago
    > It's time developers realised they are plumbers not artists. If we're plumbers, why all the memory leaks? Or... are we also bad plumbers?
  • ykonstant 1y ago
    Speak for yourself, please.
• gt5050 1y ago
  One other course that all undergrads should take is Unix 101 Just the basics of unix (bash, cat , sed, awk) How to grep logs, tail files
  • jaza 1y ago
    Yes! Exactly that - basics of unix - was one of the first-semester courses in my comp sci degree. It has served me well ever since.
• ChicagoDave 1y ago
  I could add so much to this page. - COBOL on punch cards - RPG II/III - PDP/Vax Shared Memory Modules - Hierarchical Data File Storage - Recursive Expression Evaluator - Batch Processing large datasets - Compressed dates and numbers So many of these teach you structural complexity that you’d never learn in today’s world.
  • markus_zhang 1y ago
    Just curious what is special about PDP/Vax Shared Memory Modules? I know Win NT is basically the child of VMS and David Cutler worked on PDP before VAX, so maybe this is the reason?
    • ChicagoDave 1y ago
      You had to map out how modules would swap in and out of memory, so they had to be encapsulated modules. At least for the PDP you didn't have relational data stores so all data was in hierarchical data files (each record had a parent-child indicator, so you might read an 'M' record, then many 'D' records). You certainly could not load all of the data into memory even one set of M+D+sub records might blow out your limits. You had to carefully think through how your code worked at a molecular level always banging up against a memory wall.
      • ChicagoDave 1y ago
        This is what data prior to SQL Server and Oracle looked like: ************************************** * MEDICAL INSURANCE CLAIMS HIERARCHICAL FILE - CIRCA 1982 * * RECORD TYPES: H=HOSPITAL(MASTER) P=PATIENT D=DIAGNOSIS C=CLAIM DETAIL * ************************************** H001MEMORIAL GENERAL HOSPITAL 19820415NEW YORK NY10001212555010001520000 P001001JOHNSON ROBERT M19450312001234567819820102BCBS D001001001HYPERTENSION 401.9 19820102 D001001002DIABETES TYPE 2 250.00 19820102 C00100100119820102OV0992001200120 C00100100219820102LAB8100305003050 C00100100319820102RX1150002500250 P001002SMITH MARY F19580624002345678919820115AETNA D001002001PNEUMONIA 486 19820115 C00100200119820115ER0992505002500 C00100200219820115XR7100108001080 C00100200319820115RX1150012501250
• qwertytyyuu 1y ago
  Functional programming exists in any reputable computer science course. Standard is haskel, For a true "unlearning" it might need to be a third or forth year subject
  • pjmlp 1y ago
    On my day it was actually a mix of Miranda, Caml Light, Lisp, with Tarski's World and Prolog for FP.
• gsinclair 1y ago
  I’m interested in the history of software development, and detailed case studies. What book(s) should I read?
• ByteDrifter 1y ago
  Many computer science programs today have basically turned into coding trade schools. Students can use frameworks, but they don’t understand why languages are designed the way they are, or how systems evolved over time. It’s important to remember that computing is also a field of ideas and thought, not just implementation.
  • yanslookup 1y ago
    Which ones are those? My large state university still has the same core required classes as it did 25 years ago. I don't think CS programs can veer to far away from teaching core computer science without losing accreditation.
• penguin_booze 1y ago
  CSCI 0001: Functional programming and type theory (taught in English [0]) For decades, the academia mafia, through impenetrable jargon and intimidating equations, have successfully prevented the masses from adopting this beautiful paradigm of computation. That changes now. Join us to learn why monads really are monoids in the category of endofunctors (oh my! sorry about that). [0] Insert your favourite natural language
  • joquarky 1y ago
    Also, pure functions fit very comfortably in context windows.
• cranium 1y ago
  I'd add classes about: - telling clients that the proof-of-concept is non-conclusive so it's either bag it or try something different - spending innovation tokens in something else than a new frontend framework and/or backend language - understanding that project management methods are tools (not rites) and if your daily standup is 45min then there's a problem
  • dapperdrake 1y ago
    Only "frackend" is the real framework placement. Beats both frontend and backend. And alway reimplement Perl in NodeJS. For Internet points.
• ochrist 1y ago
  SQL
• epolanski 1y ago
  Jm2c but people tend to conflate two overlapping but different fields. CS is the study of computation, SE is the study of building computer programs. Those overlap in the same way physics and chemistry do. Of course the two overlap and chemist's are also exposed to classical and quantum physics and know about Dirac spaces or Born-Oppenheimer equations. But the bulk and core of a chemist curriculum will involve few of these courses and with a focus on what's relevant to the chemist. E.g understanding how quantum physics make water appear transparent in a glass but blue in a lake or deep pool. Same is for CS and SE. Of course they are related, but CS is much more focused on the theoretical and mathematical parts of computing, not the practical side of building systems. One wants to know what can be computed and how and with what properties. The other wants to know how to build computer programs, but does not need to understand and be intimate with the mathematics of type inference or Hoare logic.
  • kragen 1y ago
    "Software engineering" is the political ideology that the study of management practices can enable you to deliver a successful software project without learning how to program. It is very popular in fields where a software project can be considered successful without ever delivering usable software, such as cost-plus defense contracting, management consulting, and enterprise software. If you want to know how to build computer programs, then learn the type system of your chosen language, and learn how to reason about the behavior of sequences, loops, and conditionals—even if you do it informally or with small-step operational semantics instead of Hoare logic, and even if your language doesn't have type inference. Don't listen to the comforting lies of "Software Engineering" promising easy shortcuts. There is no royal road to Geometry, and there is no royal road to Google. Git gud. But it is also true that there is a great deal that you could learn about computer science that you do not need to write working software, fast. Sequential search is often fast enough. Simple hash tables are usually better than fancy balanced trees. You will probably never use a computer that uses one's complement or the network stack the OSI model describes. If you have an array to sort, you should probably use a sorting function from the system library and definitely not implement bubble sort from scratch. Or even Quicksort. You can program in Erlang or Java for decades without having to understand how the garbage collector works. There are some good posts on the blog that do a good job of explaining: https://prog21.dadgum.com/177.html https://prog21.dadgum.com/177.html https://prog21.dadgum.com/87.html https://prog21.dadgum.com/87.html
• zkmon 1y ago
  > CSCI 2100: Unlearning Object-Oriented Programming?? People in tech industry, seem to have no idea how the systems in the wild work. Enterprise Java runs the backbone of operations for all of large business organisations such as banks. It is just as grounded as MS Office is. It is object-oriented software that is running the bulk of production environments of the world. Who is going to maintain these systems for the next few decades? And in reality, there is nothing wrong with Java or object orientation. It has the best battle-tested and rich ecosystem to build enterprise systems. It mirrors the business entities and a natural hierarchy and evolution of things. It has vast pool of skilled resources and easy to maintain. Python is still a baby when it comes operational readiness and integrations. You might get excited about Jupyter cells and REPL, but that is all a dev-play, not production.
  • m_rpn 1y ago
    That happened not by choice, but by chance and due to "OOP consultants" running rampant in the 2000s. Source: i have to maintain Java slop in a bank, and used to maintain Java slop in manufacturing.
  • globular-toast 1y ago
    Banks as an example of "getting things done" is laughable. Real industry gets things done: manufacturing, construction, healthcare etc. We could do without the massive leech that is the finance sector.
    • znpy 1y ago
      I still get my monthly salary via wire transfers, no issues… banks do get things done.
      • freetonik 1y ago
        A lot of wire transfer code and other foundational banking code is written in COBOL.
      • m_rpn 1y ago
        Not thanks to Java or OOP, but despite it. You can thank my colleagues fighting Java in the bank each day.
• toolslive 1y ago
  what about a "Failed Concepts" course? Things that seemed like a good idea, but ultimately don't work. (fe, ORMs come to mind)
• kkfx 1y ago
  What's really missing is: - a basic computer science course, teaching how to be at home in a FLOSS desktop system - an intermediate course teaching how to properly automate this environment, from scripting to classic development - a basic course in networking and system management to reach the level of being able to be a dummy sysadmin at home all of these must be preparatory to CS because without them it's like studying literature before knowing the basics of the language in which it's written. So far, it's assumed that students do it themselves, but the facts prove that this is not the case.
• austin-cheney 1y ago
  I would add: PSYC 2230: Measuring Things - Gathering evidence, overcoming bias, and comparative analysis. Most developers cannot measure things at any level, in any regard. CSCI 5540: Transmission Control - Comparative analysis of existing data transfer protocols, to include practical application, as well as authoring new and original protocols Most developers don’t know how any transmission protocols work internally, except possibly HTTP CSCI 3204: Tree Traversal - Data structure analysis applied to data model hierarchies and taxonomies I have heard from so many developers who say they spend most of their education on data structure analysis but in the real world cannot apply it against tree models in practical application on any level. The people in library sciences figure this out in the real world but not educated software developers.
• soruly 1y ago
  CSCI 3210: Modern text encoding and processing Learn unicode and utf-8. Unlearn the 1 char = 1 byte concept Not only encoding/decoding but searching and sorting is also different. We may also cover font rendering, unicode modifiers and emoji. They are so common and fundamental but very few understand them.
  • lor_louis 1y ago
    Handling text is a minefield. UTF-8 is great but when you get into graphemes, there's basically no way to handle them properly unless you write some code to generate graphene recognition based off the spec which is rather large and continuously updated. Same for font rendering, there is a reason why harfbuzz is used everywhere. Getting an 80% working renderer is easy but the remaining 20% can take years. It really "handling text correctly"should be a masters, and I'd sign up in a heartbeat.
• jhylands 1y ago
  CSI 5000 epistemological foundations of AI Its always frustrated me how little consideration to the existing study of knowledge is given in AI courses
• w4rh4wk5 1y ago
  For CSCI 2100: Unlearning Object-Oriented Programming I'd recommend Casey Muratori's Handmade Hero series. Also check out https://www.youtube.com/@BetterSoftwareConference https://www.youtube.com/@BetterSoftwareConference
  • TheAceOfHearts 1y ago
    Let's be real for a moment. I just looked it up and found a playlist for the full Handmade Hero series which contains 696 videos. Adding up the total duration of the playlist gave me a time of 4726711 seconds, or 1313 hours. Even for the most passionate of developers, you're gonna have a hard time getting someone to commit even a fraction of that time towards educational content. If you think there are any specific videos from the Handmade Hero series that are really worth watching, you should recommend them directly. But pointing someone to 1300 hours of content is an absurd suggestion.
    • w4rh4wk5 1y ago
      You don't watch the full playlist from start to finish. You start and keep watching until "you get it". Most of the foundational stuff is of course at the beginning. Feel free to pick the topics you find interesting, like allocations, etc. There's a sizable community around Handmade Hero which can point you to more specific topics.
• xtiansimon 1y ago
  “Never had one lesson.” Ferris Bueller Self-taught Python, and PHP before that. The course I always wanted might be named, “Systems: static and flexible abstractions” Which is an expression of the frustration I had trying to learn frameworks (I forgot I attempted to learn Drupal until I read this question), where I found it nearly impossible to ask questions on SO (a lot of ‘stay in your lane’ remarks). And the frustrations I feel today when I try to reconcile my understanding of Python used in the ‘systems’ I created for CLI scripts, and the baffling brain fog I experience when trying to understand how someone else’s code works.
• squirrellous 1y ago
  There should be a course on Linux. Not your typical operating systems course where you write a toy OS and teach a bunch of theory, but rather a deep dive into various Linux subsystems, syscalls, tooling, etc.
  • michaelrpeskin 1y ago
    Actually, I think it should be the inverse of that. A CS student should come into CS!01 after hacking for years as a teenager and know how to use something like Linux from a practical standpoint and then college course should be all about the theory and ideas. I remember when I was 10 or 12 or so hacking with my IBM 8086 and using basic, I accidentally "invented" the bubble sort. In fact, mine was extra slow and inefficient because both my outer and my inner loop went from 1 to N and there was no early exit if no swaps were made. A true O(N^2) algorithm. I didn't now what O(N^2) meant, but I had some understanding the things quickly got slower. Then later in CS101 I learned about big-O and all the theories around sorting and it immediately clicked because I had a deep understanding of something that I experienced and then could tie it to real theory. The other way around - learning the theory before the experience - wouldn't have worked as well. To tie it to your comment, you should have a deep experience with your OS of choice and then when you go to school, you learn why things are the way they were. When I say this I often get accused of gate keeping, but I don't view it that way. I look at it as other types of majors that have existed longer than CS. I often make an analogy to music majors. I can't enroll as a freshman and say I'm going to be a music major without ever having played an instrument. People get accepted to a music department after they demonstrate the ability (usually though the equivalent of hacking while they were kids), and in their music classes they learn theory and how to play different instruments (just like learning different OSes or languages). I kind of feel that CS should be the same way, you should show up to CS101 knowing how to do things from deep experience. You may not know any of the whys or theory, that's fine, but you should have experience in doing. To tie it back to the parent: you should come to CS knowing how to run Linux, maybe because you copied configurations or scripts from the dark corners of the internet. And then the CS classes should be around why it's all that way. E.g., you know that to schedule something you use cron; and CS would be a discussion around how generic OSes need a way to schedule tasks.
• anthk 1y ago
  Zork? I prefer advent and Spider and Web. Just kidding, I'd put Rogue/Nethack and Slashem too. Thanks to Rogue we have Curses and NCurses. Also, Eliza and Megahal plus Markov Chains.
• vitallan 1y ago
  something on the lines of "software paleontology" where you learn how to deal with REALLY legacy software think about decompile java apps that don't even have the original version control anymore, change it, and deploy it again
  • joquarky 1y ago
    ...deploy it again straight to prod because there aren't any other environments. Prepare to swap back quickly if something goes wrong. Yep, I've been there.
• xg15 1y ago
  CSCI 2171: User Experience of GUI tools - Learn how to design a graphical user interface that empowers the users instead of coercing or manipulating them. - Prerequisites: Any course that used the term "funnel", "user journey", "A/B tests" or "engagement". - Includes a historical bonus part about "Native UI Toolkits" (not part of the exam)
• codeulike 1y ago
  CSCI 3240: Ignoring Hype - How to ignore the latest platform/library/thing everyone is talking about on HN CSCI 3120: Novelty Driven Development - How to stay interested in your job by using the latest platform/library/thing everyone is talking about on HN even if it isn't actually necessary NB: CSCI 3120 cannot be taken at the same time as CSCI 3240 PSYC 4870: Meeting Techniques - mentioning problems before, during or after meetings - different techniques for different manager types - small talk conventions in different cultures - camera on or camera off - the modern split in corporate habits PSYC 5630: Accepting Organisational Friction - how to motivate yourself to write documentation that no-one will ever read - managers are people too - understanding what makes someone think they want to be a manager - Everything Will Take A Long Time And No-one Will Remember What Got Decided - working in large organisartions - Cake and Stare - how to handle a leaving do
  • unnah 1y ago
    There should also be PSYC 5640: How to become a guru by reading the documentation everyone else is ignoring. Cannot be taken at the same time as PSYC 5630.
• trgn 1y ago
  > CSCI 2100: Unlearning Object-Oriented Programming If anything, we need the opposite of this class. Learn OO well and create tight apps with a small runtime footprint, well isolated code boundaries, and clean interfaces.
• __MatrixMan__ 1y ago
  This article and most of the comments around here seems to have mistaken computer science and software engineering. I wish software engineering degrees were more common so I could've studied computer science like I intended to.
• LgWoodenBadger 1y ago
  I would have loved a class on the Theory of Version Control. Unfortunately, I didn't learn about it until my first job after I graduated. Architectures (centralized, distributed), implementations (diffs, patches, full state, etc.), branches, merges, etc.
  • Taikonerd 1y ago
    Yes! I was a CS major. But when I got my first job out of school in 2005, I had never encountered version control before. It was very hard learning that from zero, on top of everything else that everyone learns in their first job. All of which is to say: yes, this should totally be a course!
• jillesvangurp 1y ago
  I think the misconception here is that studying computer science prepares you for a career as a software engineer. It helps but there are a lot of blind spots in the curriculum that boil down to the notion that academics don't really tend to have engineering backgrounds. The fix isn’t stuffing the curriculum with pet topics, because the list of useful ones is practically endless. And it would get outdated soon anyway. I actually did a phd in the topic of software engineering and I had to learn a lot of stuff after I started practicing what I preached. I realized that this was the case while I was working on my thesis and it was a big reason for me to get some hands on experience. Basically, academics tend to have a lot of somewhat naive notions about software engineering that usually manifest in them waffling about things like waterfall style development or emphasizing things like formal methods, which in 30 years of practice, I've rarely encountered in the wild. That doesn't mean teaching that is a waste of time. But it does mean that there's more to software engineering than is taught in universities. You can't really learn most of that from someone that hasn't been exposed to real life software engineering. Most academics never leave university so they are not necessarily that up to speed with modern practices. Teaching in most engineering disciplines boils down to a lot of theory followed by apprenticeships. The theory doesn't evolve nearly as fast as practice and tools. That's why it's fine using somewhat outdated or academic languages and tools in university. I don't think that's unique to computer science either. Studying computer science gives you a theoretical basis and the ability to learn. Which is nice and relevant. But I actually know a lot of software engineers that studied completely different topics (theoretical physics, philosophy, mathematics, geology, etc.) that do fine without it. A few years of working can compensate for that. Having an academic background prepares people to wrap their heads around complex new stuff. Getting a degree basically means "you have a working brain". The most important skill you learn in university is using your brain. I don't care what language people use in university. But I'd prefer people to have been exposed to more things than just 1 language and knowing that there are multiple ways to do the same thing. I did logic, functional, and imperative programming in my first year. OO was kind of hot and newish but that was a second year topic. I later studied aspect oriented programming as well (there are several flavors of that) and a few offshoots of object oriented (prototype based, role based). Many javascript programmers may have never heard of the language Self. But that's one of the the languages that inspired Brandan Eich; it's a prototype based OO language (no classes, just prototype objects). That's the difference between a good engineer and one with a decent computer science background. You don't need to know that to use Javascript. But it helps.
• ChaoPrayaWave 1y ago
  After reading this article, I suddenly remembered an elective I took in college called “Software Archaeology.” The professor asked us to reimplement compiler exercises from the 1970s. At the time it felt useless, but later I realized that course taught me more about system design than any modern framework ever did.
  • NBJack 1y ago
    Software archaeology in its most literal form would be a fantastic course addition for anyone going into a company with a medium-large codebase > 5 years old. Especially if you end up at a FAANG or something akin to it. Being able to navigate not just a codebase but bugs/tickets attached to it, discussions in documents, old wiki pages that half work, extracting context clues from versioning history, tracing people by the team they worked on at the time...digital detective work is a serious part of the job sometimes.
    • joquarky 1y ago
      I just realized that I spent at least ten years as a professional software archaeologist. That company develops most of the court software used in the US. And it's very unlikely that they have improved their practices in the three years since I had to leave due to burnout.
• lexszero_ 1y ago
  If you enjoy good old grumpy bitterness like this article, you might also enjoy revisiting the classics: - https://harmful.cat-v.org/software/ https://harmful.cat-v.org/software/ - http://n-gate.com/ http://n-gate.com/
• ok123456 1y ago
  > PSYC 4410: Obsessions of the Programmer Mind Identify and understand tangential topics that software developers frequently fixate on: code formatting, taxonomy, type systems, splitting projects into too many files. Includes detailed study of knee-jerk criticism when exposed to unfamiliar systems. Each class would "just" study a hackernews thread in depth.
  • xg15 1y ago
    Going by HN preferences, I'd also add "in-depth typography" and "medieval books" for some reason.
    • ok123456 1y ago
      Also gut microbiome, theories about diet and exercise grounded in things other than thermodynamics and moving more, and how things ought to be taught in school.
• javier_e06 1y ago
  CSCI 4330: Software Cotillion Class Learn the group etiquette during meetings for task assignment and interacting with supervisor authority. Emphasizes being respectful and polite, with lessons on manners like handshakes, greetings, and helping others. Cotillion classes often culminate in a formal backlog grooming and lessons-learned where students display their learned skills.
• Ekaros 1y ago
  UX design on resource constrained systems First make a modern UI for sufficiently complex application. Then make students to improve it to be usable on low memory, low cpu, high network latency and slow network speed system...
• tpoacher 1y ago
  I disagree with the sentiment and implied haughtiness behind all those course suggestions, but ok.
• deleted 1y ago
  [deleted]
• IsaacNeutron 1y ago
  CS isn’t even really a science but learning its history can help a creative technologist not merely create new solutions but find new problems in the gaps. Alan Kay is someone worth listening to. Such courses have existed in a number of universities, just with different course titles.
• hakfoo 1y ago
  CSE 419: Resume-driven development. Develop strategies for injecting the latest buzzword tech even though you're performing maintenance for a 1990s PHP or Java 2 codebase that has no business case for it. Term project involves ripping out a reliable, fast server-side rendered app with fourteen megabytes of React that panics when a mosquito flicks its wings.