Eugene Wallingford

Never thought I would see a professor from my alma mater show up on the front page of HN! I could have maybe seen Dr. Wallingford (http://www.cs.uni.edu/~wallingf/) for his love of functional programming or Dr. McCormick (http://www.cs.uni.edu/~mccormic/) for contributions to ADA, but not Dr. O'Kane! Took Database Systems from Dr. O'Kane. He was a pretty fun professor.

Are you trying to find a hacker to join you as a co-founder, or are you just looking to outsource the development? If it's the former you might find it difficult. See: http://www.cs.uni.edu/~wallingf/blog/archives/monthly/2010-12.html#e20… If it's the latter, just ask your connections to recommend a good outsourced development shop, or wait for somebody here to chime in.

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…

>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

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#e20… 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…

One fun assignment at Oxford's Comp. Sci. department was solving Mastermind in Haskell using minmax. Knuth has a particularly fun paper on it in fact - https://www.cs.uni.edu/~wallingf/teaching/cs3530/resources/knuth-maste…

“The Computer as Master Mind” PDF: https://www.cs.uni.edu/~wallingf/teaching/cs3530/resources/knuth-maste… It minimizes the worst-case, not the expected number of moves. I think Knuth’s algorithm can be beaten in that respect.

The Knuth approach said to be implemented in this post (but it looks like the code in the post simply guesses at random?) is described in: > The computer as Master Mind. Journal of Recreational Mathematics 9 (1976), pp. 1–6. Reprinted with an addendum as Chapter 25 of Selected Papers on Fun and Games. (https://www.cs.uni.edu/~wallingf/teaching/cs3530/resources/knuth-maste… is the original paper, but the addendum in the 2011 book is 5 pages long, longer than the original article itself (not counting its figure/table), and discusses various later results/ideas.)

The language has, perhaps, a bit too much Chuck Moore: Don't reuse code, don't make code reusable, and don't try to anticipate anything. The knob is turned all the way over to the "simplicity of implementation" end of things, and all else be damned. http://www.cs.uni.edu/~wallingf/blog/archives/monthly/2017-10.html#e20…

See also BAD HABITS AND HAPHAZARD DESIGN the typically incite full by Eugene Wallingford http://www.cs.uni.edu/~wallingf/blog/archives/monthly/2015-02.html#e20…

The grand-daddy of bash based static site generators: http://nanoblogger.sourceforge.net Example use: http://www.cs.uni.edu/~wallingf/blog/ (9 years) Incidentally, the creator of nb announced that he is postponing the development of nb indefinitely last month. OP: Do you think you might want to take up that development?

Knowing and Doing, reflections of an academic and computer scientist: http://www.cs.uni.edu/~wallingf/blog/index.html

Here's a blog post written in reaction to this one: Thinking out loud about the compiler in a pure OO world. http://www.cs.uni.edu/~wallingf/blog/archives/monthly/2012-03.html#e20…

I've heard about 17 different versions of this story, which are probably all bullshit. Here's a few: http://pinds.com/2007/05/27/knowing-which-screw-to-turn/ http://www.guidancechannel.com/default.aspx?M=a&index=658&cat=… http://www.cs.uni.edu/~wallingf/teaching/agile/sessions/session27.html http://pocky.tumblr.com/post/49520543/knowing-which-screw-to-turn

The advice to learn a variety of programming paradigms is sound: http://mvanier.livejournal.com/998.html http://matt.might.net/articles/best-programming-languages/ -------------- I haven't read pyHardWay, but I think it's vaguely in the lineaage of why's: http://www.cs.uni.edu/~wallingf/teaching/188-agile/ruby/whys-poignant-… and for FP: http://learnyouahaskell.com/ http://learnyousomeerlang.com/content http://www.lisperati.com/clojure-spels/casting.html Also, SICP, little schemer. Others?

Here are a few that I don't think have been mentioned yet: The Cooper Journal http://www.cooper.com/journal/ Google Testing Blog http://googletesting.blogspot.com/ Knowing and Doing http://www.cs.uni.edu/~wallingf/blog/

Thanks for that link. His site is very interesting, the functional programming patterns especially: http://www.cs.uni.edu/~wallingf/patterns/recursion.html

>"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.…

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…

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_s… 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-maste… an implementation: https://github.com/johnathanlouie/mastermind further development: https://arxiv.org/abs/1908.06183