diff options
Diffstat (limited to 'blog/content/notes')
7 files changed, 274 insertions, 10 deletions
diff --git a/blog/content/notes/index.gmi b/blog/content/notes/index.gmi index b2908890..807835d6 100644 --- a/blog/content/notes/index.gmi +++ b/blog/content/notes/index.gmi @@ -1,5 +1,6 @@ # Notes +=> interesting-articles Interesting articles => greek-task-list Greek task list ## Cliff's notes @@ -33,6 +34,8 @@ Notes about some books and long articles I like: => tech/misc-python-stuff Misc Python stuff => tech/python-modules-primer Python modules primer => tech/so-you-want-to-play-with-functional-programming So you want to play with functional programming +=> tech/motivating-example-for-logical-replication-for-dynamic-ui Motivating example for logical replication for dynamic UI +=> tech/about-web-development About web development ### Gadgets diff --git a/blog/content/notes/interesting-articles.gmi b/blog/content/notes/interesting-articles.gmi new file mode 100644 index 00000000..73e8f881 --- /dev/null +++ b/blog/content/notes/interesting-articles.gmi @@ -0,0 +1,195 @@ +# Interesting articles + +## General + +=> https://lukeplant.me.uk/blog/posts/no-one-actually-wants-simplicity/ No one actually wants simplicity +Simplicity is sacrifice. See also: +=> https://www.youtube.com/watch?v=SxdOUGdseq4 simple made easy (video) +=> https://www.seangoedecke.com/wicked-features/ wicked features + +=> https://www.geoffreylitt.com/2025/03/03/the-nightmare-bicycle.html Avoid the nightmare bicycle +Good designs expose systematic structure; they lean on their users’ ability to understand this structure and apply it to new situations. + +## Programming + +=> https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.html The Configuration Complexity Clock +Programming languages, configuration files, DSLs for configuration + +=> https://olano.dev/2023-11-30-code-is-run-more-than-read/ Code is run more than read +A unified theory of broken software + +=> https://www.teamten.com/lawrence/writings/java-for-everything.html Java for Everything +The advantages of focusing on a single language and how performance and static typing are helpful. + +=> https://en.wikipedia.org/wiki/Ostrich_algorithm Ostrich algorithm + +=> https://blog.brownplt.org/2024/04/12/behavior-misconceptions.html Finding and Fixing Standard Misconceptions About Program Behavior +About the Standard Model of Languages (SMoL) + +=> https://dannorth.net/best-simple-system-for-now/ Best Simple System for Now +A view I disagree on about IAGNI and the opposite concepts, but interesting + +=> https://mmapped.blog/posts/38-static-types-perfectionism Static types are for perfectionists +Our programming style is influenced by our personality and life + +=> https://www.joelonsoftware.com/2005/05/11/making-wrong-code-look-wrong/ Making wrong code look wrong +The history about Hungarian notations + +=> https://www.hillelwayne.com/talks/ese/ddd/ What We Know We Don't Know: Empirical Software Engineering +40-minute video about the power of proper sleep, working schedules and stress levels vs. engineering practices + +=> https://www.hillelwayne.com/post/we-are-not-special/ We are not special +Second of a series of three articles comparing software engineering with traditional engineering. Mostly dispels some myth and lack of knowledge about traditional engineering. + +### Testing + +=> https://testing.googleblog.com/2014/05/testing-on-toilet-risk-driven-testing.html Testing on the Toilet: Risk-Driven Testing +"Your tests are a means. The bang is what counts. It’s your job to maximize it." + +=> https://testing.googleblog.com/2024/10/smurf-beyond-test-pyramid.html SMURF: Beyond the Test Pyramid +Test categories and the pyramid are excessively limited models. + +### Python + +=> https://lukeplant.me.uk/blog/posts/pythons-disappointing-superpowers/ Python’s "Disappointing" Superpowers +A convincing defense of dynamic typing + +### Rust + +=> https://www.hezmatt.org/~mpalmer/blog/2024/05/01/the-mediocre-programmers-guide-to-rust.html The Mediocre Programmer's Guide to Rust +=> https://qouteall.fun/qouteall-blog/2025/How%20to%20Avoid%20Fighting%20Rust%20Borrow%20Checker How to Avoid Fighting Rust Borrow Checker + +### Optimization + +=> https://docs.oracle.com/cd/E11882_01/server.112/e41573/technique.htm The Oracle Performance Improvement Method +My favorite text about performance tuning- the good advice is not Oracle-specific. Includes a bit more real-world advice than: +=> https://users.ece.utexas.edu/~adnan/pike.html Rob Pike's 5 Rules of Programming + +=> https://infrequently.org/series/performance-inequality/ The Performance Inequality Gap, 2024 +=> https://danluu.com/slow-device/ How web bloat impacts users with slow devices +About janky browser applications and websites. + +### Git + +=> https://blog.gitbutler.com/git-tips-3-really-large-repositories/ Git Tips 3: Really Large Repositories + +### Accessibility + +=> https://xogium.me/the-text-mode-lie-why-modern-tuis-are-a-nightmare-for-accessibility The text mode lie: why modern TUIs are a nightmare for accessibility + +## Systems + +=> https://chrisdown.name/2018/01/02/in-defence-of-swap.html In defence of swap: common misconceptions + +## Organizations + +=> [[https://charity.wtf/2024/07/24/pragmatism-neutrality-and-leadership/ Pragmatism, Neutrality and Leadership +(The parts about "As a leader, your job is to succeed", "Companies with shitty cultures win all the time".) This article connects with: +=> https://hbr.org/2007/03/why-i-wrote-the-no-asshole-rule The no asshole rule book + +=> https://charity.wtf/2017/05/11/the-engineer-manager-pendulum/ The Engineer/Manager Pendulum +Why people should multiclass engineering and management + +=> https://varoa.net/2024/01/09/how-organisations-cripple-engineering-teams-with-good-intentions.html How organisations cripple engineering teams with good intentions +Arguments for having coders code + +=> https://stackoverflow.blog/2024/06/10/generative-ai-is-not-going-to-build-your-engineering-team-for-you/ Generative AI Is Not Going To Build Your Engineering Team For You +Bad title; it's about the need for junior coders + +=> https://luminousmen.com/post/senior-engineer-fatigue Senior Engineer Fatigue + +=> https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/ Things You Should Never Do, Part I +About rewriting software from scratch + +=> https://dl.acm.org/doi/10.1145/1464122.1464146 Some observations concerning large programming efforts +Someone figured most of it out in 1964. + +=> https://www.jofreeman.com/joreen/tyranny.htm The tyranny of structurelessness +=> cliffs/the-tyranny-of-structurelessness (My Cliff's Notes) + +=> https://www.lesswrong.com/posts/tscc3e5eujrsEeFN4/well-kept-gardens-die-by-pacifism Well-Kept Gardens Die By Pacifism +About moderation in small communities + +### Project management + +=> https://apenwarr.ca/log/20171213 An epic treatise on scheduling, bug tracking, and triage +No non-sense opinions on project management I mostly agree with + +## News + +=> https://www.currentaffairs.org/2020/08/the-truth-is-paywalled-but-the-lies-are-free/ The Truth Is Paywalled But The Lies Are Free +Excellent title, but the article is so-so + +## Society + +=> https://locadeldesvan.com/2025/01/09/contra-la-tecnocratizacion-de-la-vida/ Contra la tecnocratización de la vida +About the pressure of the modern age and the privilege of being mediocre + +=> https://www.experimental-history.com/p/face-it-youre-a-crazy-person Face it: you're a crazy person +Choosing a job because you like the worst parts of it + +## Epistemology? + +=> https://hermiene.net/essays-trans/relativity_of_wrong.html The Relativity of Wrong by Isaac Asimov +All physics theories are strictly "false", but they are very true. + +## Meta + +=> https://www.benkuhn.net/progessays/ Essays on programming I think about a lot +=> https://www.piglei.com/articles/en-programmer-reading-list-part-one/ A Programmer's Reading List: 100 Articles I Enjoyed (1-50) + +## Infrequent but useful terms + +=> https://en.wikipedia.org/wiki/Abilene_paradox The Abilene paradox +A collective fallacy, in which a group of people collectively decide on a course of action that is counter to the preferences of most or all individuals in the group, while each individual believes it to be aligned with the preferences of most of the others. + +=> https://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect The Dunning–Kruger effect +A cognitive bias in which people with limited competence in a particular domain overestimate their abilities. Some researchers also include the opposite effect for high performers: their tendency to underestimate their skills. In popular culture, the Dunning–Kruger effect is often misunderstood as a claim about general overconfidence of people with low intelligence instead of specific overconfidence of people unskilled at a particular task. +=> https://www.frontiersin.org/journals/psychology/articles/10.3389/fpsyg.2022.840180/full A Statistical Explanation of the Dunning–Kruger Effect +This effect might only be caused by subjects in the bottom quartile can only make optimistic errors placing themselves into a higher quartile, while subjects in the top quartile can only make pessimistic errors placing themselves in a lower quartile. + +=> https://en.wikipedia.org/wiki/Gell-Mann_amnesia_effect The Gell-Mann amnesia effect +A cognitive bias describing the tendency of individuals to critically assess media reports in a domain they are knowledgeable about, yet continue to trust reporting in other areas despite recognizing similar potential inaccuracies. + +=> https://en.wikipedia.org/wiki/Goodhart%27s_law Goodhart's law +An adage that has been stated as, "When a measure becomes a target, it ceases to be a good measure". + +=> https://en.wikipedia.org/wiki/McNamara_fallacy The McNamara fallacy +(Also known as the quantitative fallacy) involves making a decision based solely on quantitative observations (or metrics) and ignoring all others. + +=> https://en.wikipedia.org/wiki/Hanlon%27s_razor Hanlon's razor +An adage, or rule of thumb, that states: Never attribute to malice that which is adequately explained by stupidity. + +=> https://en.wikipedia.org/wiki/Hawthorne_effect The Hawthorne effect +A type of human behavior reactivity in which individuals modify an aspect of their behavior in response to their awareness of being observed. + +=> https://en.wikipedia.org/wiki/Novelty_effect Novelty effect +An effect of introducing new elements on some activity or behavior. + +=> https://softwareengineering.stackexchange.com/questions/123627/what-are-the-london-and-chicago-schools-of-tdd What are the London and Chicago schools of TDD? + +=> https://en.wikipedia.org/wiki/Sturgeon%27s_law Sturgeon's law +An adage stating "ninety percent of everything is crap". + +=> https://en.wikipedia.org/wiki/Schedule_chicken Schedule chicken +When two or more parties working towards a common goal all claim to be holding to their original schedules for delivering their part of the work, even after they know those schedules are impossible to meet. Each party hopes the other will be the first to have their failure exposed. + +=> https://everything2.com/title/Your+radical+ideas+about+society%252C+individualism%252C+and+religion+have+already+occurred+to+others Your radical ideas about society, individualism, and religion have already occurred to others + +=> https://en.wikipedia.org/wiki/Slate_Star_Codex#Lizardman's_Constant Lizardman's constant +The approximate percentage of responses to a poll, survey, or quiz that are not sincere + +See also: + +=> greek-task-list Greek task list + +Sources: + +=> https://en.wikipedia.org/wiki/List_of_paradoxes List of paradoxes +=> https://en.wikipedia.org/wiki/Unintended_consequences Unintended consequences + +## Lost and not found + +Some articles I'd like to find here, but haven't been able to find again: + +* Enqueuing function calls vs. extending your domain model: This article discussed using traditional queues for handling some actions in your application vs. doing this "declaratively". For example, enqueue "send notification about x to user y" vs. "add column 'needs_x_notification to users table". If I remember correctly, the article contained some insightful arguments for the latter approach I had not thought of. diff --git a/blog/content/notes/tech/about-relational-databases.gmi b/blog/content/notes/tech/about-relational-databases.gmi index c66a530f..d08071ac 100644 --- a/blog/content/notes/tech/about-relational-databases.gmi +++ b/blog/content/notes/tech/about-relational-databases.gmi @@ -21,7 +21,7 @@ Many computer languages have similar concepts: * C++ std::map * Java java.util.Map * C# System.Collections.Generic.Dictionary -* Javascript Object +* JavaScript Object * PHP arrays Relations are a natural concept, so although non-relational data systems exist, most data can be stored as relations. diff --git a/blog/content/notes/tech/about-web-development.gmi b/blog/content/notes/tech/about-web-development.gmi new file mode 100644 index 00000000..bcc54cb8 --- /dev/null +++ b/blog/content/notes/tech/about-web-development.gmi @@ -0,0 +1,5 @@ +# About web development + +* Ensure that the website is as functional as possible using limited browsers such as Lynx, ELinks, w3m, or Dillo. (If you use a browser that can display images, ensure that the website is as functional as possible with images disabled too.) +* Make sure all content in the website has a URL that can be shared conveniently. +* If website users would benefit from learning about updates to your website, then provide well-visible open ways to follow updates, such as RSS/Atom feeds, email subscriptions, or ActivityPub feeds. diff --git a/blog/content/notes/tech/gadgets/pocket-computers.gmi b/blog/content/notes/tech/gadgets/pocket-computers.gmi index a31970ef..e2cd7a2f 100644 --- a/blog/content/notes/tech/gadgets/pocket-computers.gmi +++ b/blog/content/notes/tech/gadgets/pocket-computers.gmi @@ -8,16 +8,8 @@ The Blackberry KeyONE I used 2017-2021 was the last device I used that had this Since then, I believe the loss of physical keyboard phones means that some uses of the smartphone have disappeared. -=> https://www.bringbackblackberry.com/ - ## Current devices -=> https://www.unihertz.com/products/titan-pocket Titan Pocket (owned) - -* The keyboard feels worse than a Blackberry -* The keyboard has deteriorated with age (some keys require extra pressure to activate, meaning typing is painful) -* The keyboard software is insufficient for writing in Spanish and Catalan - => https://www.clicksphone.com/communicator Clicks Communicator => https://www.clicksphone.com/powerkeyboard Clicks Power Keyboard => https://keyphone.tech Keyphone @@ -29,6 +21,14 @@ Since then, I believe the loss of physical keyboard phones means that some uses => https://www.tindie.com/stores/zitaotech ZitaoTech refurbs keyboards, but they seem to be permanently out of stock. => https://linkapus.com/ The Q25 project is a project to put an Android phone inside a Blackberry Classic shell. +## Recent devices + +=> https://www.unihertz.com/products/titan-pocket Titan Pocket (owned) + +* The keyboard feels worse than a Blackberry and deteriorates with age (some keys require extra pressure to activate, meaning typing is painful) +* The keyboard software is insufficient for writing in Spanish and Catalan +* My battery swelled and I retired it + ## Obstacles ### Communication platforms without an open API diff --git a/blog/content/notes/tech/misc-python-stuff.gmi b/blog/content/notes/tech/misc-python-stuff.gmi index 6672e021..f7cc33e7 100644 --- a/blog/content/notes/tech/misc-python-stuff.gmi +++ b/blog/content/notes/tech/misc-python-stuff.gmi @@ -39,7 +39,7 @@ The standard library still includes a lot of batteries: * textwrap.dedent and str.[lr]strip for embedding multiline strings in code. * urllib.request is clunkier than third-party libraries, but it's usable. -(Also for very simple stuff, tkinter can implement simple graphical tools.) +For very simple stuff, tkinter can implement simple graphical tools and wsgiref can implement simple web apps (that you can even deploy with CGI). ### Subprocess diff --git a/blog/content/notes/tech/motivating-example-for-logical-replication-for-dynamic-ui.gmi b/blog/content/notes/tech/motivating-example-for-logical-replication-for-dynamic-ui.gmi new file mode 100644 index 00000000..01fc5fae --- /dev/null +++ b/blog/content/notes/tech/motivating-example-for-logical-replication-for-dynamic-ui.gmi @@ -0,0 +1,61 @@ +# Motivating example for logical replication with dynamic UI + +(I'm almost sure what I write below is a horrible idea that will melt a PostgreSQL server with very few "real-time queries" at the same time. I'm very curious about how much load could PostgreSQL handle efficiently using this schema.) + +Suppose the following database schema (pseudo-SQL): + +```sql +create table chat_messages ( + id serial primary key, + posted timestamp not null, + channel text not null references chats(id), + author text not null references users(id), + message text not null +); +``` + +Imagine you could write an UI element that subscribed to the following publication: + +``` +create publication foo for table chat_messages where (channel in :list_of_channels_user_is_in and posted > :some_time_ago); +``` + +Without writing any additional code, the UI element would get instantly notified not only of all new messages, but also of editions, deletions, or messages moved in or out of the subscribed channels. I believe you could write a real-time UI element with much shorter and safer code than any alternative I can think of that only uses OSS code. (As far as I know, ksqlDB does a similar thing, but has non-OSS bits and seems much harder to deploy than PostgreSQL, besides you would also need to deploy PostgreSQL.) + +This has some caveats: + +* Publications cannot do "joins", and implementing any live UI element that requires joins would be much more complex. (And I'm not sure it would still be the best way to implement things.) +* This likely cannot be implemented efficiently without having all working set data in RAM (e.g. all the data involved in all subscriptions). + +My idea is writing: + +* A daemon that provides an API that can be used as in the following example: + +``` +subscription = subscribe("chat_messages", column("channel").in(list_of_channels) and column("posted").gt(some_time_ago)) +while update = subscription.next(): + for chat_message in sorted(update.all_current_results(), key=lambda chat_message: chat_message.posted): + print(chat_message.current_values, chat_messages.previous_values) + print(update.deleted_since_last_update_results()) +``` + +* Libraries for stacks such as "Django + HTMX", "GTK", etc. that allow to build UI elements that use the daemon API underneath, so you could write things like: + +``` +<ul class="channels"> + {% foreach channel in joined_channels %} + <li> + {{ channel.name }} + last message: {{ for chat_message in update_all_current_results() if chat_message.current_values.channel == channel | max(lambda chat_message: chat_message.current_values.posted) }} + </li> + {% end foreach %} +</ul> + +<ul class="current_chat_messages"> + {% foreach chat_message in update.all_current_results() if chat_message.current_values.channel == current_channel %} + <li>{{ chat_message.current_values.author }} {{ chat_message.current_values.message }}</li> + {% end foreach %} +</ul> +``` + +For stacks such as Django/HTMX, in simpler websites you could have websites that degrade gracefully out of the box without JS, just losing real-time updates. |