Eugene Wallingford

Last sentence first: Objective-C certainly has (optional) static types and protocols[1][2], or as Java calls them, interfaces. In fact Java interfaces were "borrowed" from Objective-C[3]. In fact, Objective-C needs the types of a message's arguments and return value in order to generate correct code in the general case, and since message names can be ambiguous it needs to know the static type of the receiver (or "close enough") in order to know those static types in the message. If all arguments and the return value are objects, then this is not necessary, this "id subset" has some nice properties.[4]

In Smalltalk, the messages an object responds to are called its protocol.[5]

"Every object in Smalltalk, even a lowly integer, has a set of messages, a protocol, that defines the explicit communication to which that object can respond."

Now that that single protocol for the entire object can be split into multiple meaningful protocols should be obvious, but Alan Kay has also explicitly talked about objects embodying "multiple algebras"[6]

The basic idea of "protocol oriented programming" is that you focus on what an object can do (its interface/protocol) rather than what it is (its class/type) and that Smalltalk certainly did. Whether you check this statically is a secondary and certainly orthogonal concern, but of course there were and are statically typed variants of Smalltalk (such as Strongtal) and type-systems for others Smalltalks.

Traits were introduced in 2003…

I can't seem to load the page...

That said while we're on this topic, I've always enjoyed Drew Houston's take on it:http://www.quora.com/How-do-I-find-good-technical-co-founders

"Unfortunately this is a classic problem. "How do I find a really hot single girl to go out with?"

* Good technical people will have ideas of their own that they're excited about, and working for a non-technical founder who, by the way, doesn't know or appreciate the difficulty or time it takes to make something well-engineered and undervalues you from an ownership standpoint, gets old quickly.

* People who are not hands-on building the product at the very early stage of the startup are usually not terribly useful until later, because building the product is most of the real work early on.

* Good engineers have a wealth of compelling opportunities at any given time, so it gets even worse if the non-technical founder is inexperienced, or hasn't already brought a lot to the table (funding, etc.) See, for example, http://www.cs.uni.edu/~wallingf/blog/archives/monthly/2010-12.html#e2010-12-01T15_45_40.htm one view of how technical people perceive "idea guys" who "just need a programmer."

So, what can you do?

* One is look for a technical cofounder, not just an early employee, and give commensurate equity. Again, bear in mind that frankly he or she will be more valuable than you at this phase.

* Two is learn to code enough to bang out a prototype -- this will also make you a better engineering…

There was a talk by M. J. Dominus ... "Design Patterns" Aren't https://perl.plover.com/yak/design/samples/slide001.html

While the narration of the talk itself is likely lost to time and "people weren't recording everything in 2002"... the slides linked are reasonable signposts of the author's ideas.

The key points I believe occur on slide 12.

Patterns vs. "Patterns"

The pattern language does not tell you how to design anything

It helps you decide what should be designed

You get to make up whatever patterns you think will lead to good designs

---

I believe that people read the GoF Design Pattern book as a textbook or bible rather than what the authors were doing of "these are things that we discovered while writing a word processor" ... and are useful ways of looking at those problems. But then those patterns got enshrined in some holy temple as you need to do these things and this is how you build software".

Patterns got turned into a prescriptive thing that people do to build software and for a long while people were often coming up with the question "did I discover a new pattern" ... which when you read Alexander's book becomes a silly question.

My own rant on the cult of pattern... https://the-whiteboard.github.io/2016/09/02/patterns.html

... One of my favorite pages to link on career advice is Find the Hard Work You're Willing to Do https://news.ycombinator.com/item?id=26209541 ... The previous blog post that shows up on that same page is…

>"It is wrong to suppose that if you can’t measure it, you can’t manage it – a costly myth."

Ironically, this may have been a reaction an early software management book in the 80s by Tom DeMarco of Peopleware fame and similar books that were popular at the time. It's kinda annoying that the people that are maintaining a website in Deming's name don't reference the first edition book dates for the quote attributions. The original book seem to have been published in 1993 (when Deming was 93...), whereas the quote is attributed to a 2018 third edition on the website.

The reason I find it ironic is that Deming seems to have been critiquing the young (relatively) influential upstarts at the time like DeMarco for over-emphasizing the importance of management metrics, And as it turns out, the nuances in his approach turned out to be more compatible with the approach that came to dominate the post-millennial software landscape (led by Google/Facebook at the time)--ie rigid process-averse lower case agile. It turns the out of touch senile old guy was more prescient than the new suits.

Although DeMarco started deviating from his early utopian management approach when he published Peopleware, it wasn't until the late 20000s when he did a a complete 180 and wrote a mea culpa, disavowing his earlier management books and the "You can't control what you can't measure" quote attributed to him [1].

[0] https://www.cs.uni.edu/~wallingf/teaching/172/resources/demarco-on-se.pdf

>But I think there will always be that feeling of: a human being took the effort to write this. No matter how informative or well written an AI article or comment is, it isn't something we instinctively want to respond to, the way we do when we know there is a person behind the words.

Over and over again, when reading comments from some folks who lionize the usage of LLM outputs, as well as other folks who demonize such usage, I'm reminded of this bit from Kurt Vonnegut's Cat's Cradle[0], specifically from the "Books of Bokonon"[1]:

Beware of the man who works hard to learn something, learns it, and finds
himself no wiser than before. He is full of murderous resentment of people
who are ignorant without having come by their ignorance the hard way.

And I wonder if, (myself included) those who demonize LLM usage are those who "came by their ignorance the hard way."

I'll admit that the analogy isn't great, but there is something to it IMNSHO. Mostly that many who distrust (and often rightly so) LLM outputs have a strong negative impression (perhaps not "murderous resentment," but similar) of those who use LLMs to spout off.

I suppose this is a bit tangential to the topic at hand, but if it gets anyone to read Cat's Cradle who hasn't already, I'll take the win.

[0] https://en.wikipedia.org/wiki/Cat's_Cradle

[1] https://www.cs.uni.edu/~wallingf/personal/bokonon.html

You're framing it like an information extraction game, but it is also frameable as a zero-sum minimax game. And its an easy, and common solution to games like this. Read up.

https://en.wikipedia.org/wiki/Mastermind_(board_game)#Algorithms_and_strategies https://en.wikipedia.org/wiki/Minimax#In_zero-sum_games

One of the early solutions to mastermind was by Donald Knuth. paper: https://www.cs.uni.edu/~wallingf/teaching/cs3530/resources/knuth-mastermind.pdf an implementation: https://github.com/johnathanlouie/mastermind

further development: https://arxiv.org/abs/1908.06183