Eric Lippert

Lots of the ones already mentioned here are great. One I don't see mentioned here is Eric Lippert's blog. He is just now concluding a 35-part series on Conway's Game of Life and in particular the Hashlife algorithm, which includes one of the most mind-blowing programming concepts I have had in years. https://ericlippert.com

More abstractly, programmers who do not serialize their data are doomed to litter that data through their type system. This blog post series is an absolute classic read on the topic. https://ericlippert.com/2015/04/27/wizards-and-warriors-part-one/

Hey, I've also used and loved Orpie! I'm not extremely familiar with any of the ML family, but Eric Lippert had a blog series I followed for a while in which he was writing a Z-Machine in OCaml: https://ericlippert.com/2016/02/01/west-of-house/ I followed along but in Rust for a while, though I think he paused the project at some point and I lost steam. I learned more about Rust (which, IIRC was first implemented in OCaml) than I did about OCaml, but it's always seemed like a nice language.

This is how I use LINQ as well. With some non-standard names, it has everything you need! Eric Lippert wrote a great series on monads tying it to LINQ: https://ericlippert.com/2013/04/02/monads-part-twelve/

It, according to Eric Lippert, was at least partially to fix the problem of vexing exceptions[1] that plagued Int32.Parse. Parse was first and it was kind of an unfortunate design decision to make a almost expected result (parsing to fail) throw an exception. It's worth noting that nowadays Parse is just a wrapper around TryParse that throws (although this is an implementation detail) [1]: https://ericlippert.com/2008/09/10/vexing-exceptions/

Eric is no longer with Microsoft, by the way. He was previously on the C# compiler team. I believe he was at JetBrains when I last looked him up. Looks like his blog "Fabulous Adventures in Coding" is on his website now: https://ericlippert.com/ (I worked with him briefly in, I think it was, 2005.)

There's an Eric Lippert post from a few years back about working on the C# compiler, where he followed a similar spec-guided approach, with simpler benefits for both making the code clear and making sure the spec was reasonable: > [...] I wrote all the conversion logic in Roslyn, and I did so for the most part by carefully following the specification. This had two purposes; first, to be sure that I was implementing the actual specification, and second, as yet another chance to ensure that the specification made sense. For much of the conversion code I have methods where each method implements one line of the specification, for this reason. https://ericlippert.com/2015/05/26/a-different-copy-paste-error/

Oh! https://ericlippert.com/ now has 5 "Retrospective" posts up about https://beanmachine.org/ . Hmm, but no easy way to link to the set ("Uncategorized").

Sorry to hear about the lay-off. I can't stress enough how influential Eric Lippert was on my early career. His work on C# and .NET, but more importantly his openness and engagement with the community played a big part in me continuing on the Microsoft stack. Just jumping into any random month[1] in his blog archive from my formative years is incredible nostalgia for me. It's not the kind of high-concept "a monad is a monoid in the category of endofunctors" content that will make the front page of HN, but was a great pipeline of information for a junior .NET developer hungry to learn. [1] https://ericlippert.com/2009/08/

There is a more-or-less comprehensive archive[1] up to 2019 (which should probably be scraped and hoarded). The article in question is there, comments included[2]. Side note: Michael Kaplan’s blog, which Microsoft took down in a remarkably shameful manner, has also been archived[3], while Eric Lippert reposted (most of?) his old articles on his personal WordPress instance[4]. [1] http://bytepointer.com/resources/old_new_thing/index.htm [2] http://bytepointer.com/resources/old_new_thing/20110921_226_why_do_win… [3] http://archives.miloush.net/michkap/archive/ [4] https://ericlippert.com/

There's also Eric Lippert's blog series on OOP and business rules [1] that culminates [2] in suggesting a DSL with Inform7 as a possible candidate. The comments on the final post are great as people rail against the use of a DSL. [1] https://ericlippert.com/2015/04/27/wizards-and-warriors-part-one/ [2] https://ericlippert.com/2015/05/11/wizards-and-warriors-part-five/

I recommend sharing this article: https://ericlippert.com/2015/04/23/dry-out-your-policies/

Ahah, your comment has the same vibe as this great fiction of how would Richard Feynmann pass a "lateral-thinking puzzle" interview question. https://ericlippert.com/2011/02/14/what-would-feynman-do/

This is sort of tangentially related, since TFA doesn't really talk about long hours as such but I definitely prefer the following angle: https://ericlippert.com/2019/12/30/work-and-success/

Note for readers who want to search for more: ECS is "Entity Component System" And Eric Lippert has a fantastic series of blog posts where he also discusses this problem: https://ericlippert.com/2015/04/27/wizards-and-warriors-part-one/

Eric Lippert did a nice blog post on this sort of thing a few months ago: https://ericlippert.com/2020/03/27/new-grad-vs-senior-dev/ The other points he mentions, beyond constant factors, are that algorithms with great theoretical characteristics tend to interact really poorly with gross real-world considerations like the memory hierarchy, and that worst-case performance is not average-case performance.

Great way to learn more about Zork and the Z-machine: Eric Lippert wrote an ocaml implementation and blogged about it https://ericlippert.com/2016/02/03/north-of-house/

Eric Lippert's blog series on Monads[1] follows this approach and is very effective in teaching the concepts behind Monads. He starts out with standard concepts from C# that are Monads and shows how they're implemented and what they have in common. It is very approachable for an object-oriented programmer who's curious about functional programming. 1: https://ericlippert.com/2013/02/21/monads-part-one/

Somewhat relevant, Eric Lippert recently had an excellent 40-part blog series about fixing randomness: https://ericlippert.com/2019/01/31/fixing-random-part-1/

Aha! You're right. I misremembered this excellent blog series from Eric Lippert (a member of the c# design team): https://ericlippert.com/2013/02/25/monads-part-two/

Eric Lippert's blog https://ericlippert.com/ He used to write about C#, mostly. Now he is into functional programming. Awesome content.

Eric Lippert[0] is doing an "excessive explanation" of this paper[1], where he breaks the entire paper down, line by line, with examples that C#/Java people would recognize. It's nice for people like myself who are strong on concepts, but weak on notation. ex: map : ∀α ∀β ((α → β) → (α list → β list)) Which I previously couldn't read, but I could easily explain the concept. [0] - Former C# language designer, Roslyn compiler team, etc. https://www.reddit.com/r/programmerchat/comments/37qwmm/i_am_eric_lipp… https://ericlippert.com/about-eric-lippert/ [1] - https://ericlippert.com/?s=excessive&submit=Search

Thanks for the link. I hadn't read the interview, though I had read the following by Eric Lippert where he references it: https://ericlippert.com/2014/03/03/living-with-unchecked-exceptions/ I'm not really a fan of checked exceptions either for the reasons that Anders Hejlsberg outlines in the interview. However, the bit where he writes: "I'm a strong believer that if you don't have anything right to say, or anything that moves the art forward, then you'd better just be completely silent and neutral, as opposed to trying to lay out a framework." Isn't that exactly what has happened with unchecked exceptions in C++ and C#? They've added complexity compared with C style error codes, without actually moving the art forward.

The fact that the generated javascript doesn't look as neat is a pretty poor argument. Does the author avoid other language features that get "lowered" (http://ericlippert.com/2014/04/28/lowering-in-language-design-part-one… into less elegant code as part of the execution? In time, we'll not see this code as it'll all happen within the javascript engines, but all features of javascript are still abstractions over lower level code. How about writing a loop over asynchronous functions? Now that is unpleasant to look at, and most examples I've seen use recursion which is pretty limiting. That is one of the best reasons to embrace async/await

So, I don't get all the pain. There are a lot of 'rules' around monads, but conceptually they are widgets in a workflow. In imperative programming you say what you want to do and do it at the same time. With monads, you assemble a chain, just like dropping boxes on a workflow UI. Just like a workflow, you have 'defined' what to do, but not done anything with it yet. When you give it input, the chain performs the transforms you have defined for it, and you can pull out the result. Again, not a 'technical definition' but this paints a picture in people's heads that they can appreciate and follow it up with details. For serious learning, I recommend Eric Lipperts blog post on the subject: http://ericlippert.com/category/monads/

One of them is Eric Lippert. If you use C# you'll enjoy his blog, http://ericlippert.com/.

Holy strawmans, Batman! This article sets up a false dichotomy (virtually nobody argues for designing for "future needs", it's more like varying degrees and definitions of "cleanliness"), then gives examples of terrible code at both ends of this dichotomy, and settles it with very mediocre code in the middle. IExternalRuleService? Is that supposed to resemble anything anyone sane would ever do? Do people literally write "Car : Vehicle" out of their 1st year of college anymore? Let's assume we're all past those strawman examples and talk about the proposed "Balanced Approaches" instead. ShoppingCart looks to be re-writing an in-memory collection. Is it actually adding anything beyond "Collection<Item>"? (Substitute with whatever collection type you like in your language). Do you actually need a class at all? There simply isn't enough specified in the article to tell. Therefore there's no lesson here: the code as-is shouldn't exist, and we can't tell what ShoppingCart is actually supposed to be doing. If it's making database calls, you have multiple major problems. The best advice I can give in that situation is: don't do, just plan. RemoveItems should take something that can be interpreted into SQL (or whatever's appropriate for the persistence you're using) and return a plan that can be composed with other plans. IRefuelable, IParkable, IEngineOperable ... these seem to be missing the point that interfaces are defined by their consumers, not by their implementations. You…

The second answer cites Lippert's pre-existing blog post on the subject: https://ericlippert.com/2009/11/12/closing-over-the-loop-variable-cons… I agree that there will be some degradation here, but I also think that the developers inclined to do this kind of outreach will still find ways to do it.

"[My probabilistic languages] team in particular was at the point where we were regularly putting models into production that on net reduced costs by millions of dollars a year over the cost of the work. ... We foolishly thought that we would naturally be protected from any layoffs, being a team that reduced costs of any team we partnered with. ... The whole Probability division was laid off as a cost-cutting measure. I have no explanation for how this was justified and I note that if the company were actually serious about cost-cutting, they would have grown our team, not destroyed it." https://ericlippert.com/2022/11/30/a-long-expected-update/#:~:text=We%…

Eric Lippert's "Complete Guide to BSTR Semantics" explains this well: https://ericlippert.com/2003/09/12/erics-complete-guide-to-bstr-semant…