Simple Made Easy
Hi, original author here. Some comments: > We sign the records so that authenticity can be determined without polling the home server, and we use a repository structure rather than signing individual records so that we can establish whether a record has been deleted (signature revocation). Why do you need an entirely separate protocol to do this? Email had this exact same problem, yet was able to build protocols on top of it in order to fix the authenticity problem. This is the issue: instead of using ActivityPub, which is simpler to implement, more generic, and significantly easier for…
one of most important: - get a mentor. Some chilled senior guy with lots of experience. Speak to him regularly to fish for knowledge. But don't get hung up on everything s/he says. Programming is huge field with lots of parts. others: - there is no silver bullet - simple is not easy (search Simple Made Easy by Rich Hickey) - always be pragmatic - there are indeed better approaches than OOP, which differ greatly in long run of project, and pay back (FP) later, and it matters - avoid "the chase" of latest best-good thing, get productive in something that matures well - don't ignore…
It definitely can be. I'm constantly trying to push our stack away from anti-patterns and towards patterns that work well, are robust, and reduce cognitive load. It starts by watching Simple Made Easy by Rich Hickey. And then making every member of your team watch it. Seriously, it is the most important talk in software engineering. https://www.infoq.com/presentations/Simple-Made-Easy/ Exhausting patterns: - Mutable shared state - distributed state - distributed, mutable, shared state ;) - opaque state - nebulosity, soft boundaries - dynamicism - deep inheritance, big objects, wide…
> I thought I adressed that; everything I mentioned - explicit error returns, pure functions, no global state, and no metaprogramming - all show their true worth in large and/or unfamiliar codebases. I agree with all of those. I try to avoid these things whenever I write code (in rare cases, there are valid reasons for using them, but I agree they are overused). But that still leaves tons of room for different ways of writing code, and it's very hard to say which one of these is "obvious". Obvious to whom? Some people want to have large methods, so they can see everything at a glance,…
I second this, as personally I believe that async is an anti-pattern. It's an unfortunate result of the programming world choosing easy over simple so it could recruit vast armies of inexperienced programmers for profit: "Simple Made Easy" by Rich Hickey: https://www.youtube.com/watch?v=LKtk3HCgTa8 I'm old school, I want the runtime to do as much work for me as possible so I don't have to. Basically that looks like the runtime providing things like process isolation and concurrency, even if the underlying hardware can't do that. Especially if we're using a high-level scripting language like…
If you haven't watched it before, I'd recommend "Simple Made Easy" by Rich Hickey. [0] The reason I say that is because you say "conceptually simple" as if that's a bad thing. Maybe we have to agree to disagree, but in choosing a framework I would much, much rather go for the one that is conceptually simple (at the cost of some extra verbosity in certain cases) over one that is conceptually complex but covers up that complexity with a terse-but-incomplete API. You're not going to understand the benefits of the Vue vs. React choice by looking at idealized code samples, which is all your…
> I feel like "Complexity" is the wrong word here. [...] I'd argue its more to do with the nature of how large codebases morph over time as they're retrofitted to do more usercases. Its a lot easy in the short term to just hack in the functionality you need into an existing codebase, instead of rewriting the entire thing from scratch every time. This comes at the cost of maintainability and leads to a lot of headaches in the long term, as systems that where never designed to work together clash in unexpected ways. Rich Hickey separates complexity into two parts[0], accidental and intentional…
I would suggest to you that Clojure has a very clear "the Clojure Way" I would say, more so then almost any other language. It goes beyond syntax to a pretty deep design level. Its not even all that unique to clojure, you could do 'the clojure way' in other languages, but they usally dont. Some of the importent keynotes from some of the early conjs are really importent, and they really went deep in the community, you can see it in almost every major library. Another commenter has mentioned the notion of 'simple' but thats not really all that clear. I not enougth of a writer to tell you…
Great question, I personally recommend: 1. Simple Made Easy by Rich Hickey (video https://www.infoq.com/presentations/Simple-Made-Easy/) 2. Thinking in Systems by Donella Meadows (pdf https://wtf.tw/ref/meadows.pdf) 3. Raymond Hettinger’s content about CHUNKING is classic for this (one example video https://youtu.be/UANN2Eu6ZnM?si=TnLLj1CASwubkAS2) 4. The classic tome on Abstraction is Gödel, Escher, Bach: an Eternal Golden Braid, by Doug Hofstadter (https://en.m.wikipedia.org/wiki/Gödel,_Escher,_Bach) 5. Finally, I’ll cut myself at lucky number five by pointing you toward Jüergen…
If we ignore the details, then this is a perfect example of how simpler code should be preferred _by default_ over complex code. Both for performance and reasoning. In this case and often elsewhere, these are related things. I'm taking the definition of simple and complex (or complected) from this talk[0]. In short: Simple means individual pieces are standing on their own, not necessarily easy or minimal. Complex means individual pieces are braided together into a whole. The first code is simpler than the second. Just have a look at the two solutions and you see what I mean: The individual…