diff options
Diffstat (limited to 'blog/content/notes')
8 files changed, 374 insertions, 12 deletions
diff --git a/blog/content/notes/cliffs/the-tyranny-of-structurelessness.gmi b/blog/content/notes/cliffs/the-tyranny-of-structurelessness.gmi new file mode 100644 index 00000000..3dfc17ea --- /dev/null +++ b/blog/content/notes/cliffs/the-tyranny-of-structurelessness.gmi @@ -0,0 +1,98 @@ +# The tyranny of structurelessness + +=> https://www.jofreeman.com/joreen/tyranny.htm A copy of the original article. These Cliff's notes focus on the generic points of the article, not on its original context (the feminist movement). + +Leaderless, structureless groups as an organizational form is a reaction to over-structured society in which most of us live that give others control over us. + +Structurelessness encourages participation in discussion and personal insight, but it does not achieve more than that. + +Structureless groups struggle when they want to achieve something more specific than raising consciousness, because the groups do not want to change structure when they change their tasks, because they think other organizational forms can be anything but oppressive. + +## Formal and informal structures + +Structureless groups evolve into having tacit structure due to the diversity of the people that form them. + +Structurelessness only prevents the formation of formal structures, not informal ones. Decision-making rules are known only by those who make the decisions. + +To give everyone the opportunity to participate, structure must be explicit and the rules of decision-making must be open and available to everyone, so they must be formalized. + +## The nature of elitism + +Elites can only be groups, not individuals. + +Elites have power over a larger group without direct responsibility. + +A person is an elitist by being a part or advocating the elite, not by being notorious. + +Elites are not conspiracies, generally they are groups of friends that happen to participate in some activity together. + +Elites are communication networks because they are groups of friends that talk. + +Groups might have one or more communication networks and they might overlap. The communication networks do not necessarily have to be an elite. Multiple communication groups might compete and only one might become an elite. + +In a structured group, the group competition is public and other members of the group can arbitrate and make demands on the groups. + +Elites can be spotted in groups, they listen and don't interrupt other members more than they do with non-members. Approval of the elite is necessary for things to happen. + +Membership of the elite tends to have some required characteristic. Common themes are related to the friendship nature of the elite, but not to the effectiveness for the larger group's purpose. + +It is easier to form an elite at the beginning of the group, by bringing existing friends in. Otherwise, the elite must be formed through new effort. Elites need to maintain themselves by adding new members. Outsides might find a member of the elite to sponsor them. + +Elite forming and maintenance require time, so people with major commitments normally find it impossible to join. A formal structure of decision making helps the overworked (and others) participate in the group. + +Elites are not inevitably bad, they are only inevitable. Elites can do useful things. But elites have uncontrolled power within their group. + +Two negative consequences: liked people have power independently of their skills, which is bad for doing significant things; elites have no obligation to be responsible. The elite usually tries to be responsible to maintain their influence, but the group cannot compel them to be responsible, this is up to the interests of the elite. + +## The "star" system + +Society expects groups to make decisions and to select spokespeople. Society does not want to listen to all individuals in a group, they want to know what the group feels. There are only three ways to know group opinion: + +* Voting +* Surveys +* Spokespeople + +The public is conditioned to look for spokespeople. + +If there are no official spokespeople, the public might choose notable members of the group, but their opinions might not be representative of the group: "stars". + +The stars might not desire to be, and the members of the group might resent the stars. + +Stars cannot be removed by the group, because the group did not make them stars, only the press can. The press will listen to stars as long as there are no official spokespeople. Members of the group can attack the stars, who might then leave the group, remaining a star but maybe not aligned with the group. + +## Political impotence + +Sometimes the informal structure of a group might align with what the group wants to do, this gives the appearance of an effective group. However, this is hard to replicate. Normally these groups have four conditions: + +* They are task oriented, they were formed with a narrow and specific function. +* They are small and homogeneous, so they have good communication reducing conflicts. +* They have a high degree of communication. This normally limits the group to five people, although 10 to 15 is possible if they have subgroups. +* They have a low degree of skill specialization, so everything can be done by more than one person, so no one is indispensable. (Not everything needs to be doable by everyone.) + +Groups composed of smaller effective groups do not tend to become more effective than their parts. These groups generates much motion and few results. These groups tend to be limited to the initial founders and exclude others, esp. the nongregarious, and elitism becomes institutionalized. + +Groups without projects spend their time maintaining the elite. + +When people cannot join the group and do things, they might do things on their own, which might lead to individual creativity, but many people cannot do this and does not foster cooperative group effort. Such people might drop out of the interests of the group, or join groups with other interests, maybe with new elites. + +The old elites can perceive these new elites as misaligned threats. The old elites can accuse the new elite of attracting specific groups of people from their group. + +The old elites can become public and formalize their original power structure as a formal structure. If the informal elite was well structured they might be able to do this, but groups that required structure the most might not be able to do it, because they adhere more to the ideology of structurelessness and they are more vulnerable to a takeover. + +Unstructured groups might choose to participate in larger groups with more influence and capabilities, but they can only have little influence in the larger group and their ideas might be diffused, but rarely implemented. + +## Principles of democratic structuring + +Groups should not blindly accept or ignore traditional forms of organization. These forms might be effective or not. Structure is not inherently bad, only excess of it. + +Essential principles: + +* Democratic delegation of specific authority to specific individuals. People who show interest or willingness who are selected are committed. +* Delegates should be responsible to who selected them. This way the group controls the authorities. +* Distribution of authority over as many people as possible, preventing monopoly of power and requiring consultations. It gives more people the opportunity for responsibility and learning. +* Rotation of tasks among individuals to prevent responsibilities from being someone's property. But not too much rotation so that it prevents learning and satisfaction. +* Rational allocation of tasks; by ability, interest and responsibility instead of by standing in the group. Learn through apprenticeship rather than sink or swim. Do not demoralize people by having responsibilities you cannot do well. Do not blacklist people from doing what they can do well. +* Diffusion of information to everyone as frequently as possible, giving individuals more power. +* Equal access to resources needed by the group. Resources owned by a member can be controlled by a member. This includes skills and information. + +These principles prevent informal elites. diff --git a/blog/content/notes/index.gmi b/blog/content/notes/index.gmi index 15dc5db1..807835d6 100644 --- a/blog/content/notes/index.gmi +++ b/blog/content/notes/index.gmi @@ -1,15 +1,16 @@ # Notes +=> interesting-articles Interesting articles => greek-task-list Greek task list ## Cliff's notes -Notes about some books I like: +Notes about some books and long articles I like: => cliffs/mythical-man-month The Mythical Man-Month => cliffs/governable-spaces Governable Spaces => cliffs/peopleware Peopleware - +=> cliffs/the-tyranny-of-structurelessness The tyranny of structurelessness ## Tech => tech/misc-linux-stuff Misc Linux stuff @@ -33,6 +34,8 @@ Notes about some books 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. |