Paul Cantrell
Provocative assertion (maybe), for discussion:
The traditional computer science curriculum has an outdated center of gravity — nor just wrt industry and employment, but wrt intellectual inquiry.
The central problem of computing now is not designing, analyzing, and using •algorithms and data structures•, but rather designing, analyzing, and using •abstractions•.
If the field is a tree, we should view the latter as its trunk, the former as an important branch of its root system.
Paul Cantrell
This suggests that “install unfamiliar languages and libraries and figure them out” should be a cornerstone of the curriculum.
And taken to its extreme — again, I’m being provocative; not sure even I believe this part, but try the idea on for size — this would imply the good old familiar “link lists, trees, and Dijkstra’s algorithm” curricular path should be an •elective•.
2/2
Paul Cantrell
@fuzzychef
Taking the sarcastic (and well justified) question seriously: I’m sure employers who want to filter candidates for privilege and access will have no trouble continuing to find ways to do so.
Berkubernetus
@inthehands but what will Google do for their infamous interviews, then?
Paul Cantrell
@fuzzychef
Yup. And even the lower level stuff like machine code and memory model is still all abstractions. Unless you’re dealing with chip layout and transistors…no wait, the raw chemistry and physics of the chips…no wait, still abstractions….
It’s good to have practice using •logical• abstractions to think carefully about what we think our •code• abstractions mean, and about how we implement them. Good devs do this in a wide variety of ways, not all trad-CS-flavored.
Berkubernetus
@inthehands anyway, 100% with you on the abstractions. Lower-level programming fundamentals are still useful -- but I spend 80% of my dev time dealing with abstractions.
Berkubernetus
@inthehands I've always been amused by these because I didn't go to school for CS, and yet have 20 years of production coding experience building stuff that millions rely on. So the whiteboard coding interview has always struck me as a great way to hire exactly the wrong people.
"How would you build a linked list for this?"
"I'd look up some linked list samples on Stack Overflow and then write some code."
Like, duh.
Paul Cantrell
@fuzzychef I mean, it very much is where I teach
Berkubernetus
@inthehands I would also love to see "how to troubleshoot/debug" be part of the core cirriculum. Right now it's not, and students get to their first piece of real-life production code and get stuck.
Paul Cantrell
@fuzzychef Well, I do like to think I’m in a rather forward-looking dept.
Berkubernetus
@inthehands it's not most places, though. I've mentored some CS students, and it wasn't for any of them.
Paul Cantrell
@PaulDavisTheFirst
I’d argue that C++ is an abstraction (Do you write machine code?), machine code is an abstraction (Do you write microcode? Arrange transistors? Move electrons around?), memory itself is an abstraction (Do you direct the processor caches?), etc etc.
…and the the framework becomes not “is it an abstraction” (everything is), but rather “what kinds of understanding are useful for the abstractions I’m working with,” and also…
1/2
PaulDavisTheFirst
@inthehands .. challenging, yet isn't really central to "put these things in a list". At the same time, the extra features of a non-intrusive list model have radical implications for my actual code. In neither case am I writing a list implementation, but my day to day world is made up of confronting the real life intersection between these powerful abstractions (which for many programmers would not even be differentiable) and actual running code.
OK, enough. 4/4
PaulDavisTheFirst
@inthehands However ... this idea about abstractions being at the core ... while not wrong, it's really not my day to day experience as a native C++ developer writing realtime audio software with a GUI. Most of what I do all day involves grappling with the actual foibles of the language/libraries I am using, and the significance of abstraction-led design is relatively small on a day to day basis.
For example, understanding how to use instrusive lists instead of non-intrusive lists is quite 3/
PaulDavisTheFirst
@inthehands ... it seemed to me that in some ways the late 80's dream of resuable software components has been substantively achieved, which is quite remarkable. 2/
PaulDavisTheFirst
@inthehands ok, so a couple of points. Recently my daughter (PhD candidate with a masters in speech pathology) was describing how she used python or R to hook up something roughly equivalent to an LLM to a data set she was working with. It was astonishing to me - the task was basically "plumbing" a set of insanely powerful pre-written components together to get a real task accomplished.
(almost) nothing I do as a native C++ developer with 35 years of experience works that way, but still... 1/
Paul Cantrell
@PaulDavisTheFirst “Are these appropriate abstractions? How do I evaluate alternatives? How will my thinking and approach change if my abstractions change?” etc.
(There’s a silly idea running around that developers should “avoid abstractions” and this means…writing C?! My good people….)
And then yes, sometimes recursive data structures are what you need to understand the abstraction at hand! Sometimes. To me, “understand the abstraction” is the •starting point•, and leads many directions.
2/2
Paul Cantrell
@atthenius I mean, that sounds like a basic teaching attitude problem that’s much more basic that than the kind of chin-scratching curricular stuff I’m wondering about. Scheme is delightful! But teaching Scheme or anything else for adversarial reasons is a recipe for unhappiness.
legraLeGra
When I was in college, I heard that the Computer Science dept would only teach Scheme to keep some students from leveraging prior programming language knowledge & teach from scratch.
It turned me off of pursuing CS. I ended up using $matlab$ in college, then (self-taught) FORTRAN once I got into grad school and beyond. And now I have to use python or R to communicate w my students.
If Rice CS had taught C, I would have added is as a major.
So mixed feelings.
Paul Cantrell
@bookwar @doctormo @fuzzychef
There are surely abstractions for which algebraic lenses can work wonders.
I would lean more in the direction of the previous post, however: approaches that apply •principles of design• but not •mathematical formalism• to API surface typically fare far, far better than the reverse.
Aleksandra Fedorova :fedora:
It seems everyone perceives this topic with their own lens.
I was going to say "Anyone who wants to create their own abstractions,.. should be required to do basic algebra" - science of abstractions in its purest form.
WIth isomorphism, factor groups and basics of linear spaces. :)
Though as I spend so much time trying to convey the technical message with some visuals nowadays, I would enjoy design course at the Uni.
Abandoned
Abstractions are just types of leverageable mental designs. Teaching good design fundamentals should be a cornerstone of the second or third year. Anyone why wants to create their own abstractions, be they APIs, command line flags, user interfaces or even databases, should be required to do design as an art.
ShadSterling
@inthehands interesting. One thing I’ve been thinking is that CS programs fail to teach how computers work - how data is composed of bits and how abstract operations are composed of concrete operations. I think I agree that treating abstractions as the “trunk” would be good, with the caveat that they also have to cover what it is that’s being abstracted
(And they need to do a much better job of teaching practical skills like dependency management)
Paul Cantrell
@ShadSterling
What is an example of a “concrete” operation? I guarantee whatever your answer is, it’s another abstraction.
Re the practical skills: we do projects (almost always team projects) in the very first CS class, the entire intro sequence, every senior capstone course, and a majority of the other courses — and it’s like magic.
Paul Cantrell
@bookwar
Strong agree that math is about creating / evaluating / etc formalisms, not just using them.
There is an important distinction here. When I say principles of design, I mean psychoperceptual things (proportion, hierarchy, ergonomics, etc) and process things (user testing, prototyping, iterative development, etc), none of which (except maybe prototyping, maybe, debatably) are typical of mathematics. And in particular…
Aleksandra Fedorova :fedora:
I think we may be talking about the same thing. It is just that for me mathematics is not about _using_ some formalisms. It is about developing the skill which allows you to create and evaluate different formalisms.
https://fosstodon.org/@bookwar/107389047199043428
Where it may differ is that mathematics does not just create the language, it also validates it for correctness.
And it is important too.
When defining a new abstraction you need to recognize when it doesn't make sense.
Paul Cantrell
…identifying stakeholders, goals, constraints, and tradeoffs are anathema to the aesthetic of “pure” mathematics, which is to explore the surprising implications of imaginary things wherever they may lead. So I do think there’s a tension here.
Paul Cantrell
@fuzzychef
P.S. If you find yourself in this situation, and if you have any kind of communication channel to the faculty, and if they have any control at all over what and how they teach…
…a formidable if-chain to be sure…
…then the magic words are “active learning.” Reduce in-class lecture time as much as possible; spend class time with students doing hands-on work. Huge up-front investment for the instructor, but it’s •amazing• how many different problems it solves once it’s working.
Paul Cantrell
@doctormo
Oh yes, 100%. 1000%. They’re both very, very useful approaches to have in hand!
My argument is about where the center of gravity should be, but it’s certainly not an argument against the value of any particular modality of thinking.
Abandoned
@inthehands @bookwar @fuzzychef
Miles O'Brian or Spoc
Tbh, we need both types of people in many projects.
Paul Cantrell
@ShadSterling
Right. So yes, bits are an abstraction too in the schema of my OP. And at any level of abstraction, I’d want students to be comfortable:
(1) learning how to work within the abstraction (binary arithmetic, in this case),
(2) moving down a level, even if it means learning the unfamiliar (logic gates or EE or whatever), and
(3) moving up a level, even if it means giving up the familiar (because it’s now hidden).
Specific change, but there’s an underlying mindset there.
ShadSterling
@inthehands “concrete” may not be the best word, but I mean operations that act on bits, roughly machine instructions, or the lowest level where you can talk about data rather than physics. Sure, it’s an abstraction, but it’s the boundary between CS and CE
Not sure what you mean by “projects”; when I got my BS in CS we did plenty of projects, but since we only used the standard library we never had to think about dependencies
Paul Cantrell
@ShadSterling By “projects,” I mean something that:
• is student-created
• is student-directed
• is in their zone of proximal development
• ends up actually working
In the 100-levels, they use a familiar language and a prescribed library. But in Software Design & Development, they have to evaluate and select a production-ready platform / framework appropriate to their design goals, and most end up learning a new language on the fly to support that choice.
GNU social JP is a social network, courtesy of GNU social JP管理人. It runs on GNU social, version 2.0.2-dev, available under the GNU Affero General Public License.
All GNU social JP content and data are available under the Creative Commons Attribution 3.0 license.