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

I'll confirm (and then nerdily complicate) your thesis for the art-form I practiced professionally for the first half of my adult life: yes, every serious actor I've been privileged to work with knows of previous performers, and studies texts they leave behind.

I owned at one time a wonderful two-volume anthology called Actors on Acting, which collected analysis and memoir and advice going back... gosh, to Roman theatre, at least. (The Greeks were more quasi-religious, and therefore mysterious - or maybe the texts just haven't survived. I can't remember reading anything first-hand, but there has been a good deal of experimental "original practice" work done exploring "how would this have worked?"). My graduate scholarship delved into Commedia dell'Arte, and classical Indian theatre, as well as 20th century performers and directors like Grotowski, and Michael Chekhov, and Joan Littlewood. Others, of course, have divergent interests, but anyone I've met who cares can geek out for hours about this stuff.

However, acting (or, really, any performance discipline), is ephemeral. It invokes a live experience, and even if you (and mostly you don't, even for the 20th c) have a filmed version of a seminal performance it's barely anything like actually being there. Nor, until very recently, did anyone really write anything about rehearsal and training practice, which is where the real work gets done.

Even for film, which coincidentally covers kinda the same time-period as "tech" as you mean it, styles of performance - and the camera technology which enables different filming techniques - have changed so much, that what's demanded in one generation isn't much like what's wanted in the next. (I think your invocation of film directors is more apt: there are more "universal" principles in composition and framing than there are in acting styles.)

Acting is a personal, experiential craft, which can't be learned from academic study. You've got to put in hours of failure in the studio, the rehearsal room, and the stage or screen to figure out how to do it well.

Now, here's where I'll pull this back to tech: I think programming is like that, too. Code is ephemeral, and writing it can only be learned by doing. Architecture is ephemeral. Tooling is ephemeral. So, yes: there's a lot to be learned (and should be remembered) from the lessons left by previous generations, but everything about the craft pulls its practitioners in the opposite direction. So, like, I could struggle through a chapter of Knuth, or I could dive into a project of my own, and bump up against those obstacles and solve them for myself. Will it be as efficient? No, but it'll be more immediately satisfying.

Here's another thing I think arts and tech have in common: being a serious practitioner is seldom what gets the prize (if by that you mean $$$). Knuth's not a billionaire, nor are any of my favorite actors Stars. Most people in both disciplines who put in the work for the work's sake get out-shined by folks lucky enough to be in the right place at the right time, or who optimize for hustle or politics or fame. (I've got no problem with the first category, to be clear: god bless their good fortune, and more power to them; the others makes me sad about human nature, or capitalism, or something.) In tech, at least, pursuing one's interest is likely to lead to a livable wage - but let's see where our AI masters leave us all in a decade, eh?

Anyway, I've gone on much to much, but you provoked an interesting discussion, and what's the internet for if not for that?

There are always a few trolls who complain about how other people spell their words, wear their hair, format their dates, choose their clothes, etc. Usually on HN these complaints get flagged into oblivion pretty quickly. But most people don't care, preferring to read about things like the interaction between technological development and digital art forms than complaints about whether "aluminum" should actually be spelled "alumium".

Ok simple question. Have a method called increment(n) on an object called tracker. It’s used to increment tracking id values.

I want to reuse the logic of increment(n) inside another object called childHeight to increment height values.

Can I import the method and reuse it inside another object? No. I can’t.

But if increment was a pure function thats like this increment(c, n) then I can move it anywhere.

That is what I mean by modularity. For oop lack of modularity is fundamental to its design. The grouping of methods around mutating state breaks modularity.

You’re talking about a semantic issue. Grouping methods by meaning. I’m talking about a logistical issue where the grouping by semantics cannot be broken even though the logic is the same. Incrementing height and incrementing ids are identical in logic even though the semantics are divergent.

That is the problem with OOP.

There are multiple ways to handle that.

Class Number {

   static Int inc(Int n) {
      return n+1
   }

}

import static Number.inc

Class Tracker {

    Integer height = 0;

    incHeight() {
        this.height = inc(this.height)
    }

}

class Tracker extends Numbers {

    Integer height = 0;

    incHeight() {
        this.height = this.inc(this.height)
    }

}

Or

interface Number {

   default Int inc(Int n) {
      return n+1
   }

}

class Tracker implements Numbers {

    Integer height = 0;

    incHeight() {
        this.height = this.inc(this.height)
    }

}

Or my pick

class Number { //or extend the Integer class and add your methods

    int num = 0;

    inc() { 
     this.num +=1
  
     }

}

class Tracker { Number trackingId; }

class Building { Number height; }

t = Tracker()

t.height.inc()

b = Building()

b.height.inc()

All OOP does is really give you a way to group state and methods, how you use it is up to you. There is a reason almost all big software is written this way and not in Lisp.

Take a look at the Interable interfae in Java if you want some good examples of reusable functions.

It enables map, filter, stream, reduce, groupby, etc on lists, sets, etc

or collections class which gives sort, min, max, replaceAll, etc