Older Showing 367 to 370 Newer

2022-May-31

07:30

Review of iQunix F96

First off, I've been using a laptop keyboard for years, so naturally the Cherry Reds on this one feel amazing.

I was pleased that the keys don't wobble as much as some other Cherry MX-based keyboards I've touched. They still wobble a bit but I guess that's fundamental to the Cherry MX design.

An aside on the switch choice: At first I got one with MX Blue, which I was glad to swap out for Red. Why? Because

Despite the Reds being "silent", and my taking care not to bottom out hard, typing with Reds still makes an adequate clang-clang sound – it's much louder than a laptop.
Blues feel bad to my fingers. I've touched some tactile switches that feel amazing, like IBM's old buckling springs and the EC Ivy switches. Compared to those, I find it difficult to classify any Cherry MX designs as tactile, they feel like defective linears, as if they had sand in the spring. Brown is the worst, but Blue's not great.

Now for the more arbitrary design choices of the F96.

Pros

I can hit left Ctrl with the palm.

Aesthetic pros

Function keys are vertically aligned with number row
Colors

Aesthetic cons

The backlight shines through some keycaps but not others, depending on their color. On the Coral Red variant, the reddish keys are more transparent.

Cons

MEH The spacebar

My standard complaint: the spacebar is wide (6 units).

It's not much wider than a laptop's spacebar (typically 5 units), but sufficient that I'll now rarely hit the Win key with my thumb. I prefer if the Win key is right under the Z key, not so far off to the side.
To clarify, I'd prefer the spacebar a maximum of 2-3 units wide, like a Japanese keyboard. I've learned to tolerate 5 units, but to make it even wider is gratuitous.

FAIL The arrow keys

I chose the F96 because it's a compact design. It's not that I want a physically small keyboard, but the fact compact designs push keys closer together, so they're easier to reach. That's most obvious around the arrow-key cluster. But it turns out you can do this wrong, and end up worse than standard.

How to do it right: Some laptops like the Dell Latitude E7250 let me use the arrow keys with the pinky, ring and middle fingers, and at the same time use my free index finger to hold either Alt or Ctrl, both of which are close enough to the arrow keys for this. I do this thousands of times a day (Alt + Left Arrow is "back" in on most web browsers, for example).

I must give the F96 a failing grade. The Right Alt key sits exactly 3 keys away from the arrow keys! This straddles the worst-of-all-worlds territory where it's uncomfortable no matter if I use my index finger (when it's too far away) or if I use my thumb (when it's too close).

"But you could remap the keys via software!" – Actually no you can't because of the Fn key. Since Fn doesn't exist to the operating system, you can never move the Fn key unless the keyboard's own firmware provides a way, which is rare. I'd suggest to keyboard makers to place Fn somewhere less problematic, like near F12, if not meeting the gold standard of just shipping QMK firmware.

Adding insult to injury, look where the PageUp and PageDown keys are located. This makes it impossible to type Alt+PageUp or Alt+PageDown with the right hand.

Created 2022-May-31 (3 years ago)

Rhetorical analysis

#rhetoric

Rhetoric of the underprivileged

First, let's see what's typical of classical rhetoric:

Public: there is a space (agora) for adopting a stance together on general questions. Directed towards the citizens with the power to act.
Doxical: Can support arguments on listeners' doxa
Agonistic: confrontative. Not that much in genus demonstrativum, but even there, the praised's virtues are contrasted with others' flaws, the specter of the cultural outsider seen as bad.
Authoritative: the speaker typically appears as a role model showing the way forward
Closed: there is a preset thesis
Monological: speaks to listeners, not with conversants. When not monologuing, the ancients were into dialectics, a style of debate that pits two viewpoints against each other to see which one "wins", and the purpose then is to find truth, not to convince.
Persuasive

The anti-rhetorical style Karlyn Kohr Campbell observed inside women's groups (Rhetoric of Women: an Oxymoron):

Private
Not doxical: can't support arguments with shared doxa because no such thing
No antagonism: to speak in the group is to realize a sisterhood. Any antagonism is directed outwards.
Non-authoritative: the only authority is held by someone speaking of their own experiences in their own domain, but none in the group has the power to say what's the best way forward, nor are they trying to win it
Open: participants have no aim except to question what they already think of their situation, by joining a group where all speak with equal agency. Joining the group is to ``risk your very self'' in a rhetoric that doesn't wrap a fixed program.
Non-monological: nobody is standing on a podium
No persuasion: The goal is a process, not a final belief. You serve up your insights and questions, and leave it to others to see any lessons in your words.

First observed in women's rhetoric.
A classic trope used by women persuading men: the antistrephon, generally useful when you're in a lower position
Classical rhetoric is useful for a society with many internally conflicting interests, then there is a need for one unifying force that decides what's what

Women's rhetoric is forced to revolt against the ruling patriarchal system. "The choice to be moderate and reformist doesn't exist for those who propose the liberation of woman". Here it must develop an antagonistic and confrontative strategy. But it cannot support itself on a counter-doxa, because whatever such a counter-doxa may say, it has been corrupted by the current system that outwardly supports the same values as the women's movement (democracy, equality, personal independence) but in practice betrays them.
- Therefore, women's rhetoric must work with a more intentional method that reveals the contradiction in male-dominated society between its principally democratic ideas and its unfair treatment of people who happen to be women.
- It may be done through incongruous perspectives ("Is God a black woman?") or symbolic reversals (filling a term like "whore" with positive meaning). As Campbell says, the purpose is to "do violence against the structure of reality". It's a demonstrative genre that dissolves doxa instead of confirming it.
- How would a social structure look, where the women's group discussion rhetoric could be a pattern for the public discourse? We can suppose that on each point it must differ from the patriarchal system, leaving it entirely in splinters. It would mean a social order where the struggle between groups has been replaced by a peaceful cooperation (presupposing that systemic injustice and all other objective reasons for conflict have disappeared), where a general equality and respect for others has spread and where traditional positions of authority has been destroyed, where the preference for dogmatic and ideological thinking has been destroyed and a free search for truth and value is encouraged and respected in everyone, where opinions don't spread from centers of power via megaphones but are always forming and being aired in small and large groups that stand in a dialogical cooperation and where, finally, the desire to convince others about one's own opinon has been replaced with a curiosity for other perspectives, to try other positions and to recgnize their situational-bound value.
  - Which tendencies in current society have an effect towards that social structure and which have an effect in the opposite? This becomes important to recognize for whoever would like to see this form of rhetoric in political discourse.

Bitzers punkter

Exigence, En tvingande omständighet som inbjuder till retorisk handling
Audience. En publik som äger förmågan att förmedla den retoriska handlingen och därmed upphäva den kritiska omständigheten
Constraints. Alla de restriktioner eller tvingande begränsningar som talaren har att ta hänsyn till om hon eller han vill kunna övertyga publiken att betrakta eller gripa sig an omständigheten på det sätt som talaren önskar.

Retorisk publik

Den man egentligen riktar sig mot, som uppfyller Bitzers punkt om audience.

Ullen: Åkessons retoriska publik var alla framtida väljare .

Vatz

No situation is objective. Situations exist on the basis of a description of them that builds on our subjective experience of them.
The way we choose to characterize a situation always affects how we experience it. So rhetoric helps determine what the situation even is.
Situational rhetoric is a myth
☑ Creating salience

Ullen

☑ Says that Bitzer and Vatz are best seen as completing each other.
Bitzer has the approach of the analyzing rhetorician
Vatz has the approach of the speaker
☑ Bitzer views the rhetoric as an answer on the situation in a similar way that an answer answers a question.
Bitzer says that the rhetor chooses a response dependent on how they perceive the situation, althoug he also says the situation basically prescribes only one correct response, and it is on the speaker to decode the situation accurately.
☑ Koppling mellan ideologi och dåd. När någon begår terrordåd inspirerad av ideolog, delar andra med samma ideologi ansvar för detta dåd?

Fanfiction

Trovärdigheten som författare bygger på en djup och bred kunskap om fandomen.

Style

The best style is the one that doesn't get noticed.

Tegners sentens: det dunkelt sagda är det dunkelt tänkta. Isokrates skriver: Förmågan att tala väl och att tänka väl går hand i hand, och det är stilen som förenar de två.

Eva Östlund-Stjärnegårdh har studerat sambandet mellan stil och betyg i gymnasisters nationella prov i svenska. Det visade sig att varierad meningslängd och varierade fundament var viktigast, alltså att ha både långa och korta meningar, och att ha få meningar som börjar med "Det är…".

Standarddef av ironi är att säga en sak men mena det motsatta. Men detta är inte en bra def. Det kan sägas bygga på ett psykolingvisktiskt missförstånd om hur språkförståelse går till. Föreställnigen: att vi först uppfattar en bokstavlig betydelse och därefter börajr vi söka efter en annan, avsedd betydelse.

The biggest reason this def is not good is it excludes many linguistic actions.

Created 2022-May-29 (3 years ago)

2022-May-25

00:48

Your deferred or async I/O chains may not need libraries🔗

UPDATE: I have written the package github.com/meedstrom/asyncloop based on this post.

Deferred, aio, async/await: I struggled to learn their concepts for my use case. Why did I need to understand so much? Turns out they were just overengineered for my specific use case, and I suspect it's a common use case.

Suppose you just want to slice up a compute-heavy chunks of Elisp into imperceptible pieces or "stages", to keep Emacs feeling snappy:

(defun stage-1 ()
  ...)
(defun stage-2 ()
  ...)
(defun stage-3 ()
  ..)

How to run these in sequence, but have Emacs listen to user input events in between? Here's one way that embarrassingly took me four years to come up with:

(defvar my-pipeline '(stage-1
                      stage-2
                      stage-3
                      ...))

(defun stage-1 ()
  ...
  (run-with-idle-timer .3 nil (pop my-pipeline)))

(defun stage-2 ()
  ...
  (run-with-idle-timer .3 nil (pop my-pipeline)))

(defun stage-3 ()
  ...
  (run-with-idle-timer .3 nil (pop my-pipeline)))

You could even use anonymous lambdas, if you like:

(defvar my-pipeline)
(defvar my-pipeline-master-copy
  #'((lambda ()
       ...
       (run-with-idle-timer .3 nil (pop my-pipeline)))
     (lambda ()
       ...
       (run-with-idle-timer .3 nil (pop my-pipeline)))
     (lambda ()
       ...
       (run-with-idle-timer .3 nil (pop my-pipeline)))))

;; Get the ball rolling.
(funcall (pop (setq my-pipeline my-pipeline-master-copy)))

Looping through data

What about an alternative to deferred:loop, to work through a list of data piecemeal? Same basic idea:

(setq some-list '("bob@foo.com" "bill@foo.com" "dana@foo.com" "jane@foo.com" ...))

(defun work-on-that-list (that-list)
  (let ((addr (pop that-list)))
    (send-spam-mail addr))
  (when that-list
    (run-with-idle-timer .3 nil #'work-on-that-list that-list)))

;; Get the ball rolling.
(work-on-that-list some-list)

Aside

Aside: What about a "try-catch-retry" pattern, to keep running in the face of random keyboard-quit events (C-g) from the user?

First, I regret that I cannot upscale the font with which to write this:

NO.

Keyboard-quit events must successfully stop things. None of us knows better than the end user. Consider writing your code such that it's fine for the pipeline to be interrupted and not restarted until the next time it would've been naturally invoked.

But if you must, here's a second repeating timer (and here the package named-timer becomes really nice for bug prevention). Note that we also redefine the function from before to demonstrate that any time you signal an error you may as well cancel the extra timer while you're at it (you don't want a new error every 10 seconds!).

;; (This 50-line library prevents dozens of bugs and oughta
;; enter emacs core.)
(require 'named-timer)
(named-timer-run 'my-chain-restart 0 10
                 (lambda ()
                   (if some-list 
                       (work-on-that-list some-list)
                     (named-timer-cancel 'my-chain-restart))))

(defun work-on-that-list (that-list)
  (let ((item (pop that-list)))
    (send-spam-mail item)
    (when OH-NO-SOMETHING-LOOKS-WRONG
      (named-timer-cancel 'my-chain-restart)
      (error "Error encountered working on: %s" item)))
  (when that-list
    (run-with-idle-timer .3 nil #'work-on-that-list that-list)))

With that out of the way, what about interweaving the two kinds of threads? That is, the straightforward pipeline from before, but where one of its steps is meant to run repeatedly in a loop?

(defvar my-pipeline #'(do-things
                       work-on-that-list
                       do-other-things))

(defvar some-list '("foo" "bar" "baz" "fnord" "gjihjgk"))

(defun work-on-that-list () ;; now it must be a no-argument function
  (when that-list
    (let ((item (pop that-list)))
      (send-spam-mail item))
    (if that-list ;; still things in the list
        (named-timer-run 'my-chain .3 nil #'work-on-that-list)
      (named-timer-run 'my-chain .3 nil (pop my-pipeline)))))

Immediate launch

Let's take a detour and look back on the first snippet in this page, to keep things simple.

What if, most of all, we want to launch a chain immediately, even though we know the user just did something (so idle time is zero)?

(Launching immediately can be useful for example when you'd prefer to compute something right as the minibuffer gains focus, a situation tight with time pressure before the user starts typing.)

Now we can't use idle timers, but we can use something even simpler: check that current-idle-time is always higher at the end of each function than at the start.

(setq my-pipeline #'(stage-1
                     stage-2
                     ...))

(defun stage-1 ()
  (let ((T (current-idle-time)))
    ...
    (when (time-less-p (current-idle-time) T)
      (setq my-pipeline nil))))

(defun stage-2 ()
  (let ((T (current-idle-time)))
    ...
    (when (time-less-p (current-idle-time) T)
      (setq my-pipeline nil))))

(while my-pipeline
  (funcall (pop my-pipeline))

Now the pipeline will run all at once, without delay, unless the user does something, in which case it bails out to avoid blocking Emacs.

Now, what if we want to do that but gracefully fall back to idle timers, so that the pipeline will still be guaranteed to run to completion?

(defvar my-pipeline-last-idle-value)
(defvar my-pipeline)
(defvar my-pipeline-template #'(stage-1
                                stage-2
                                stage-3
                                ...))

(defun my-pipeline-chomp ()
  (when my-pipeline
    (funcall (pop my-pipeline))
    (if (time-less-p my-pipeline-last-idle-value (or (current-idle-time) 0))
        ;; If user hasn't done anything since pipeline start, go go go.
        (progn
          (setq my-pipeline-last-idle-value (or (current-idle-time) 0))
          (named-timer-run 'my-chain 0 nil #'my-pipeline-chomp))
      ;; Otherwise go slow and polite.
      (cl-incf my-pipeline-last-idle-value .3)
      (named-timer-idle-run 'my-chain .3 nil #'my-pipeline-chomp))))

;; It'll be easier to reason about if we have a separate function for
;; (re)starting.  Adapting `my-pipeline-chomp' to also be able to restart the
;; pipeline would make it horribly complex.
(defun my-pipeline-start ()
  "Re-initialize and start doing whatever this pipeline is meant to."
  (named-timer-cancel 'my-chain)
  (setq my-pipeline-last-idle-value 0)
  (setq my-pipeline my-pipeline-template)
  (my-pipeline-chomp))

Finally, to include a loop in this pipeline, you know what to do: and write one of the stage-* functions exactly like that function we named work-on-that-list, and it Just Works.

(defvar some-list '("foo" "bar" "baz" "fnord" "gjihjgk"))

(defun work-on-that-list ()
  (when that-list
    (let ((item (pop that-list)))
      (send-spam-mail item))
    (when that-list ;; still things in the list
      (push #'work-on-that-list my-pipeline))))

See my package github.com/meedstrom/asyncloop.

Emacs-Lisp

Created 2022-May-25 (3 years ago)

Factfulness

Negativity : Expect bad news
Straight lines : Lines may bend
Destiny
Blame
Urgency

Created 2022-May-23 (3 years ago)