Diary

Welcome! :-)

This is both a wiki (a website editable by all) and a blog (an online diary about the stuff Alex Schroeder reads and does). If you’re a friend or relative, you might be interested in reading Life instead of this page. If you’ve come here from an RPG blog, you might want to head over to RPG. There are other similar categories to be found on the SiteMap.

Für Rollenspieler gibt es ebenfalls eine eigene RSP Kategorie.

2019-12-10 Praising maintainers

@sir recently wrote Developers shouldn't distribute their own software, which I read shortly after Maintainers Matter (”The case against upstream packaging”).

The gist is this: distributions distribute sets of programs, picked by maintainers according to some standard of quality, and package them for end users. They are intermediaries, not adding much to the software. Can we get rid of them? The two blog posts argue that the answer is no, we cannot. The maintainers act as quality assurance.

The difference in trust between managed software repositories like Debian, Alpine Linux, Fedora, and so on; and unmanaged software repositories like PyPI, npm, Chrome extensions, the Google Play store, Flatpak, etc — is starkly obvious. Debian and its peers are full of quality software which integrates well into the host system and is free of malware. Unmanaged repositories, however, are constant sources for crapware and malware. – Drew DeVault

Just look at recent news: typosquatting malware, malicious packages, they’re everywhere, if you search for the right keywords. The problem is unmanaged software repositories.

I guess I’m lucky my beloved CPAN hasn’t been hit. I guess that’s a sign of Perl being unpopular? There’s a benefit to obscurity, at least...

Tags:

Add Comment

2019-12-10 J parsing using a sequential machine

In a comment on my last post about the J programming language, Peter Kotrčka mentioned a flaw in the simple parsing trick I had used. I was basically assuming that the numbers in my input were separated by exactly one newline (or other J “word”).

I had spent some time trying to implement a parser that just looks for digits and ignores everything else, but failed. There’s an example of a sequential machine in their help pages, but I couldn’t get it to simply emit a list of numbers.

Peter made me return to that parser and I think I finally understood how it works! Thanks. 🙂

First, create an array mapping every input byte to a code. In this case, we create an array with 256 zeroes, and then we set the code to 1 for every digit.

m=: 256$0
m=: 1 (a.i.'0123456789')}m

The result looks something like this: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... – as you can see there are a bunch of ones in there. 🙂

Next we need a state transition table. It has 3 dimensions.

  1. the first axis is the current state we’re in: 0 means we’re skipping stuff, 1 means we’re reading a number – we don’t need any more states
  2. the second axis is the current code we’re looking at: 0 means we’re looking at some byte that’s not a digit, 1 means we’re looking at a digit (this is where m is used)
  3. the third axis is simply two integers: the first one is the new state (we only have 0 or 1 to choose from), and the second one is what to do (the output code: 0 means doing nothing, 1 means start a word, 3 means emit a word and reset)

OK, so here’s how I built it:

NB.        state 0  state 1
s=: 2 2 2$ 0 0 1 1  0 3 1 0

Or graphically:

<"1 s
┌───┬───┐
│0 0│1 1│
├───┼───┤
│0 3│1 0│
└───┴───┘

Rows are the current state, columns are the input code we’re looking at.

Can you see it? I started thinking about it like this:

  1. given a string such as ’42 16’, starting at index 0, in state 0, with j being the beginning of a word pointing at -1 (in other words, no word is started) ...
  2. we look at ’4’ and get the new state from our m: 1 (as we’re looking at a digit)
  3. given this information, we need to look at the cell [1 1] (current state 0, input code 1)
  4. the new state is set to 1, and output code 1 means we begin a new word at the current index 0
  5. we look at ’2’ and get the new state from our m: still 1
  6. now we’re looking at the cell [1 0] (current state 1, input code 1)
  7. the new state continues set to 1, and output code 0 means nothing happens
  8. we look at the space character and get the new state from our m: 0
  9. now we’re looking at the cell [0 3] (current state 1, input code 0)
  10. the new state changes to 0, and output code 3 means we emit a word, starting from index 0 (that’s when we started it) up to the current position (”42”) and then we set j to -1 again

And so on.

The output code 3 means we emit a word and we do not begin a new word. This is important at the end: we could have used the output code 2 but that means we emit a word and begin a new one (j remains set), and the result is that any trailing garbage at the end is turned into a word.

And now the parser works for everything:

(0;s;m) ;: '42x16xx1'
┌──┬──┬─┐
│42│16│1│
└──┴──┴─┘

You might be wondering about the 0 at the beginning of that parser definition. The answer is that this tells the parser what to do with the words it finds. 0 means that the words end up in boxes. 2 means the word index and length, for example:

(2;s;m) ;: '42x16xx1'
0 2
3 2
7 1

At last I understand it!

Tags:

Add Comment

2019-12-10 J madness continued

Ah, the madness continues... This is for day 2 of Advent of Code 2019.

  1. Your input is a list of numbers describing a program. The instructions consist of opcodes and some parameters. The opcode 99 has no parameters and indicates that the end has been reached. The opcode 1 means addition and 2 means multiplication. They both take three parameters, namely addresses into the same, 0-indexed list: the addresses of the two operands and the address of the result. The answer is the number in address 0 when the program ends.

What follows is an example input and how it changes with each step. The arrow is the current execution pointer.

01234567891011
191032311099304050
1910702311099304050
3500910702311099304050

First, let’s read data from the file and convert into a list of numbers. We use the same code as before, dumping the commas by simply picking the elements in the odd positions. This is our “original” program.

w =. ;: 1!:1 <'original'
o =: ". > ((#w) $ 1 0) # w

Then we need a function that takes the program, and an instruction pointer, executes it, modifies the program, and calls itself again, until we’re done.

This is not J-style array processing, sadly!

step =: dyad define
select. y { x
case. 1 do.
  a =. ((y+1){x){x
  b =. ((y+2){x){x
  c =. ((y+3){x)
  n =. (a + b) c } x
  n step y+4
case. 2 do.
  a =. ((y+1){x){x
  b =. ((y+2){x){x
  c =. ((y+3){x)
  n =. (a * b) c } x
  n step y+4
case. 99 do.
  0 { x
end.
)

Some notes:

  1. select. case. do. end. is similar to other languages
  2. 3 { x gets the third element from list x
  3. we need to do it twice, because the first { gives us the address we need to look at, and the second { gives us the value at that address
  4. 4 5 } x gives us a copy of x where the fifth value has been replaced by the number 4, which is why we need pass this modified value along to the next call

This computes the solution for part 1 of the challenge:

o step 0

What’s trickier to do is the second part. We are asked to “fix” the program by replacing the second and first number by all the numbers between 0 and 99 inclusive and find the pair that results in some magic value...

Here’s how to “fix” the program:

fix =. 1 2 }

And this is how you use it. The list to the left has to be exactly two elements long.

6 7 fix 1 2 3 4 5
1 6 7 4 5

Next we need a function that takes the original program, fixes is based on the two arguments, and computes the result using our step function.

try =. (4 : '((x, y) fix o) step 0')"0

Notable things that gave me headaches:

  1. I need to write (x, y) which is different from (6 7) because space-separated numbers are a thing of their own, where as space-separated identifiers are an application.
  2. I need “rank 0” (the part at the very end) such that the function gets called for every single pair of numbers in the end, and not on whole arrays.

Here’s one example of how to call it:

12 try 2

And now let’s create a 100×100 matrix and call try for every single pair:

try/~i.100

To pick this apart:

  1. i.100 creates a list of 0–99
  2. ~ is an “adverb” and modifies the preceding “verb” such that it gets called with two copies of it’s argument, so two lists of 0–99 instead of one ...
  3. / is an “adverb” and modifies the preceding “verb” such that it results in a table, getting called for every a in x and every b in y ...
  4. try is our “verb” – so in effect we’re calling 0 try 0, 0 try 1, ... which is just what we wanted

But actually we only care for the one call that produced the correct result:

19690720=try/~i.100

This gives us a truth table: a table full of zeroes and a single one. All we need to do is unravel the matrix and find the index of that single true value and we’re done.

The reason that we’re done is that the solution is “What is 100 noun + verb?” Not quite surprisingly, as 100 is the length of a row, that’s exactly what we’re getting.

I.,19690720=try/~i.100
  1. , unravels the matrix
  2. I. find the index and defaults to finding the value 1

Tags:

Add Comment

2019-12-09 The Common Cold

I’ve been suffering from a common cold for a few days now.

But remember “Thumper’s Rule.” In the movie Bambi, Thumper the rabbit remarks that Bambi is wobbly and Thumper’s parents tell him: “If you can’t say something nice, don’t say nothing at all.”

Ah! Something nice to say about the common cold?

...

Back to the basics: Alex, what is best in life!? To read Wikipedia, of course!

Here’s something for you. If only I had followed this advice:

There is no vaccine for the common cold. The primary methods of prevention are hand washing; not touching the eyes, nose or mouth with unwashed hands; and staying away from sick people.

Common cold on wikipedia

Ah, and there’s more:

Rhinovirus-caused colds are most infectious during the first three days of symptoms; they are much less infectious afterwards.

That is to say, the hand washing must continue until the very end. There’s no way around it. They are less infectious, but not quite gone. And the cold lasts for a very long time, too!

Symptoms may begin within 16h of exposure and typically peak two to four days after onset. They usually resolve in seven to ten days, but some can last for up to three weeks. The average duration of cough is eighteen days and in some cases people develop a post-viral cough which can linger after the infection is gone. In children, the cough lasts for more than ten days in 35–40% of cases and continues for more than 25 days in 10%.

I’ve heard it say that the common cold comes for a week and goes for a week.

Tags:

Comments on 2019-12-09 The Common Cold

We have a saying that cured cold lasts for 7 days and uncured for a week. There is something true about that.

Peter Kotrčka 2019-12-10 02:49 UTC


Haha! Apparently having a headache and a running nose makes for better blogging, somehow. Weird!

– Alex Schroeder 2019-12-10 09:41 UTC

Add Comment

2019-12-09 Decentralization and Collaboration

the Internet already uses three times more energy than all wind and solar power sources worldwide can provide – About the Low Tech Magazine

Sometimes I wonder whether switching my wiki’s architecture would be worth it. Just produce static websites and leave the serving up to a normal web server. The wiki is simply responsible for the editing.

@ckeen suggested “hosting them on solar powered devices instead” and I started wondering: what’s the benefit we’re looking for? I think it should be minimal energy consumption. I’m not sure individual solar powered households is the way of the future unless we radically depopulate the planet. How will this work in an urban environment? So I think what I want is for the grid to change the mix and for energy consumption in general to fall. Next up is whether a small server at home is more efficient than a virtual machine rented elsewhere. I don’t know.

@ckeen then said “one could argue that with decentralised computers one also has the option of distributing local content without relying on the centralised infrastructure.” Good point! But now we’re getting into the question of how collaboration would actually work in such a setup. Does Secure Scuttlebutt and the like even need the concept of a wiki? Maybe not. All we might want is a curation software that allows us to say: these documents are part of the collection; here’s how to make you own collection; here’s how to merge collections from elsewhere.

Something a bit like git, except simpler. Git is inadequate for me and the non-technical people I want to work with. Having a discussion about role-playing games should not require people to know git. I need an in-browser solution I think, as that’s the only way to reach non-technical, multi-platform people.

So how do I collaborate with others? In my imagination, I’m a social creature and “go” to “public” places to get informed: the library, the coffee house, the search engine, the wiki. These are somewhat centralized but perhaps not necessarily global (even the search engine attempts to provide local relevance). But it would feel weird if I was limited to the stuff I have at home, even with a lot of exchange with others.

This exchange with known individuals, like thinkers in the old days writing letters to each other, is extremely limiting compared with what we have today.

Let’s take the Gopher world as an example and let’s consider the failure of my moku pona feeds: it was easy to add the pages collecting the large sites collecting multiple Gopher sites (Red Consensus, Zaibatsu, Republic, Gopher Club), but I’m failing to add the individual sites. I’m basically hoping Tomasino does it for me with his collection of feeds. He’s acting as my curator. It works better if some aspects are centralized.

That’s why I think wikis are not dead, yet.

I think my way of collaborating and knowledge exchange is not me writing essays and sending them out, with each of us having a collection of essays sent to us by our friends (the vision of a very decentralized network, back to the Renaissance). Instead we struggle to write the One document, the contract, the manual, the wiki page, the document collection. Having that bottleneck improves my way of thinking. Even these humble blog posts allow people to comment.

I know, many people don’t like comments – but I do. Tight interaction is how I collaborate with others. If it is all based on conversation, I can’t have conversation be slow and decentralized. I don’t need it to be globalized – but some form of centralization is good for me.

My blog-wiki centralizes what I write and the comments and conversation around them. People are free to talk about the blog posts elsewhere but they don’t often do.

My Mastodon accounts allow me to talk to friends and stranger in a federated network of instances. I doubt that I would have met a similar number of interesting people if I had limited myself to a “gossip-based” 100% decentralized system like Secure Scuttlebutt.

Limited centralization is good for me. Globalization in the hands of evil corporations, not so much. 🙂

Tags:

Comments on 2019-12-09 Decentralization and Collaboration

As someone that ejected my comment system from my site, and switched to entirely static, I too went through an anguish of should I preserve comments.

What I have done is made my email address available and a contact form (via Google Forms). Several people have emailed me, and we end up exchanging emails. Sometimes I’ll ask their permission to post something from their email.

I have found Reddit a reasonable way to post and share and solicit feedback. However, it does fall into the trap of non-federated. I tried Mastadon during the G+ exodus, but found it not quite in line with my approach. For now, what I have works well enough for me.

Jeremy Friesen 2019-12-09 17:51 UTC


Hm. I hardly ever get email. Would you have sent that comment as an email? I know that I hardly ever do that. Then again I was weaned off email because people started hiding their email as they tried to stay anonymous or avoid spam.

– Alex Schroeder 2019-12-09 22:19 UTC


If there is a form for sending that e-mail, it becomes practically as effortless as a comment, only non-public.

deshipu 2019-12-10 01:08 UTC


Sadly, sending mail is never as easy as it seems...

– Alex Schroeder 2019-12-10 09:43 UTC

Add Comment

2019-12-07 J Programming Language

It’s the month for Advent of Code! Perfect little programming problems, at least at first. I often try to solve some using different programming languages. I wasn’t particularly interested in solving any programming problems, but then I saw @codesections post their solutions using APL. This is the solution for day 2, apparently:

⎕IO←0
find_in←{
  ⍺←0 0
  t←⍺
  t[1]+←1
  ⍺[1]>99:⍺{t[0]+←1 ⋄ t[1]←¯1 ⋄ t find_in ⍵}⍵
  in←⍵
  in[0;1 2]←t[0 1]
  19690720=0⌷intcode in:t
  t∇in
}
intcode←{
  ⍺←0
  one←{r←,⍵ ⋄ r[⍵[⍺;3]]←r[⍵[⍺;1]]+r[⍵[⍺;2]] ⋄ (⍺+1)intcode(⍴⍵)⍴r}
  two←{r←,⍵ ⋄ r[(⍵[⍺;3])]←r[⍵[⍺;1]]×r[⍵[⍺;2]] ⋄ (⍺+1)intcode(⍴⍵)⍴r}
  1=0⌷⍵[⍺;]:⍺ one ⍵
  2=0⌷⍵[⍺;]:⍺ two ⍵
  99=0⌷⍵[⍺;]:,⍵
}
parse←{{((⌈4÷⍨⍴⍵),4)⍴⍵}⍎¨','(≠⊆⊢)⍵}
in_1←in←parse ⊃⊃⎕nget '02.input' 1
in_1[0;1 2]←12 2
pt1←0⌷intcode in_1
pt2←find_in in

It looks like it might break your brains! Apparently the key is maximal terseness. 🤯

Let me just quote this section from the Wikipedia page:

Game of Life

The following function “life”, written in Dyalog APL, takes a boolean matrix and calculates the new generation according to Conway’s Game of Life. It demonstrates the power of APL to implement a complex algorithm in very little code, but it is also very hard to follow unless one has advanced knowledge of APL.

life←{↑1 ⍵∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂⍵}

Yes indeed...

Anyway, the lack of a special keyboard led me to the language J. The intro on Wikipedia says:

The J programming language, developed in the early 1990s by Kenneth E. Iverson and Roger Hui, is an array programming language based primarily on APL (also by Iverson).

To avoid repeating the APL special-character problem, J uses only the basic ASCII character set, resorting to the use of the dot and colon as inflections to form short words similar to digraphs.

All right! I’m going to use it to solve the day 1 problems after confirming that I know how to do it using Racket. As it turned out, the hardest part was reading a file where numbers are separated by newlines instead of spaces. Can you believe that? It took me two days to find a solution that didn’t involve splitting and joining the entire file.

The problem is that the following gives me boxed words and the newlines are also words:

;: 1!:1<'data'

The splitting and joining:

strsplit=: #@[ }.each [ (E. <;.1 ]) ,
strjoin=: #@[ }. <@[ ;@,. ]
data =. > ;: ' ' strjoin LF strsplit 1!:1 <'data'

But today I discovered:

w =. ;: 1!:1 <'data'      NB. a boxed array of words, numbers and \n
i =. 2 * i. (# w) % 2     NB. the indexes of the numbers
n =. ". > i { w    	  NB. the list of numbers, opened

I do feel bad for constructing a list of indexes, first. Surely there’s an even better way to do this. In the code above, I’m building a list of indexes. The first line results in the following:

┌──┬─┬────┬─┐
│14│ │1969│ │
└──┴─┴────┴─┘

Here’s how to understand the second and third line:

  • # w is the tally of words, resulting in 4
  • % 2 divides it by two, resulting in 2
  • i. creates a list of numbers up to that, resulting in 0 1
  • 2 * multiplies each number by two, resulting in 0 2
  • i { w picks each element of w by the index given in i, resulting in the following:
┌──┬────┐
│14│1969│
└──┴────┘
  • ". > unboxes the array (resulting in a list of strings) and evaluates each element, resulting in a list of numbers: 14 1969

Finally! 😓

A bit later I found another way:

w =. ;: 1!:1 <'data'           NB. a boxed array of words
n =. ". > ((#w) $ 1 0) # w     NB. pick the odd ones, unbox, eval
  • (# w) is the tally of words, resulting in 4
  • 4 $ 1 0 creates an array of four elements, filling it with 1 and 0, resulting in 1 0 1 0
  • 1 0 1 0 # w picks the first and third element, resulting in the following:
┌──┬────┐
│14│1969│
└──┴────┘

And we’re back to where we were before. Slightly more elegant, I guess?

Anyway, the code to solve the first problem of day 1:

fuel =. verb define
 (<. y % 3) - 2
)
+/ fuel n

It really is terse. I need to use it some more. It feels like a language that forces you to think differently about the problems and I like that.

For the second day, I needed something to be called recursively. I took advantage of another feature of the J programming language: verbs can be monadic (taking one argument on the right, like fuel 14) or dyadic (taking two arguments, one on the left and one on the right). I wrote total such that calling it as total 14 was the equivalent of calling it as 0 total 14.

total =. 3 : 0
0 total y
:
f =. fuel y
if. f <= 0 do. x else. x + f total f end.
)

I feel dirty for using a conditional, haha. J is infecting my brains.

Now that I’ve written a toy program in J I wonder how anybody can write complex applications in it. Perhaps it could work. It still baffles me. To understand my inability to express my muteness in the language you have to understand that I was looking at table of contents of reference books and didn’t understand what I was looking at, didn’t know where to get the answers to my questions (such as how to remove every second cell of an array).

Here, take a look at these two pages. Apparently they are older and all the new documentation is maintained in a wiki, but still. Just staring at these pages was baffling.

On the other hand, wiki pages such as the one explaining why J has practically no loops – because all the primitives can act on arrays – makes me understand that Perl, my favorite language in all its weirdness did not come close to being as weird as this. All coding styles are possible in Perl but the culture went to object oriented programming instead of building on wantarray and making everything aware of “list context.” Too bad!

I guess if I wanted to recommend some pages to read in order, I’d say this:

  1. Nu Voc is the concise cheat sheet followed by links to essays
  2. Absolutely Essential Terms introduces you to words, nouns, verbs, ...
  3. Array Processing shows you how you should write your code
  4. Loopless explains how most loops disappear if your primitives are aware of arrays

Tags:

Comments on 2019-12-07 J Programming Language

I am not sure if I followed it correctly, but is the list parsing working even with, for example, two newlines?

Peter Kotrčka 2019-12-10 03:28 UTC


You are right, for my code to work it is absolutely essential that there is a single newline between every number because what I’m doing is essentially picking out the odd elements.

I spent some time trying to implement a parser that just looks for digits, but failed. There’s an example of a sequential machine in their help pages, but I couldn’t get it simply emit a list of numbers.

– Alex Schroeder 2019-12-10 09:51 UTC

Add Comment

2019-12-05 Machines ruling us

Remember Charles Stress’ blog post about companies being actual artifice life forms in the process of exploiting humans? A bit like we keep cattle, I guess.

@technomancy recently expanded on the idea on Mastodon. Here is the thread, quoted with permission:

① corporations are a form of AI, and are the dominant form of life on this planet

this one seems self-evident, but if you need some help putting the pieces together, this piece by Charles Stross might help ... or you could just watch the 1988 classic film They Live.

in any case, while there do exist corporations which can peacefully coexist with humans, most of what passes for peaceful coexistence these days is either accidental or due to humans regulating corporations. regulatory capture is making the latter less and less common.

② “software is eating the world” is simply survival of the fittest

when a company can offload more of its internal processes from humans to software, it’s simply becoming more adapted to its environment and more competitive. it can change faster in response to threats, and there is less of a chance for humans to interfere.

many tech companies got to where they are now by meeting human needs, but consider the ones that have become as powerful as governments. do you think that if humans stopped needing the things they produced, or if the non-monetary cost became too high (abuse of amazon’s human warehouse workers, for instance) that they would quietly go away?

③ when machines no longer need humans, they won’t dispose of them using weapons

it’s not going to be like Terminator--weapons are costly and inefficient. when humans are no longer needed, the machines grind them to dust by means of capitalism, which is their native element.

note the use of present tense here.

unlike the priests who serve cthulu in order to be favored by the gods and killed first, humans who work with software will be destroyed last, because they are useful for the longest. you can already see this in many tech-heavy cities where the only people who can afford to live there are the ones working in software.

④ leadership isn’t

it’s possible that the corporate task of “decision making” will be rid of its need for humans before the task of “software maintenance” will. you can see foreshadowing in companies where leaders who refuse to put profit above human factors or sustainability get replaced by more willing collaborators.

companies actually getting rid of their human executives seems pretty far-fetched; what seems more likely is a situation in which they are symbolic figureheads that simply pronounce decisions which have been made for them elsewhere in the machine.

⑤ helping companies produce software is problematic

for many tech companies, the way they prey on humans is obvious. facebook and twitter turn human attention into cash and power while emitting human misery as a waste product; amazon works towards ensuring humans can no longer purchase products from non-amazon sources; google simply attempts to gatekeep literally all the world’s information.

some companies I’ve worked for seem neutral because all they do is provide tools for producing software. so far so good; in theory producing software is neutral. but there’s a big difference between producing software for humans and producing software for tech companies; the latter is simply a way of facilitating the process of a company becoming more adapted to its environment; see #2 above.

⑥ it’s (probably) not too late

I mean, I hope?

one reason I’m drawn to the fediverse is that it proves we can still make enclaves for ourselves where humans make the rules.

while the GDPR legislation means a lot of extra toil for me at work, it also fills me with determination, because it shows that there are still places in the world where humans can tell companies what to do, and they have to obey.

I want to see more of that.

Thank you for writing it down so succinctly.

Tags:

Add Comment

2019-12-05 Commonplace Books

On Mastodon, @chrisod recently mentioned the commonplace book, a scrapbook where people collected quotes, listed books to read, took notes. I myself love wikis but my life is full of little notebooks. My wife has one for holiday plans, for plants, for bills; I have them for my role-playing game campaigns: whether I’m a player or a referee, each campaign has a notebook.

For my day to day todo lists, I’ve tried bullet journals but I lack the discipline to make it a ritual. I use it as a todo list for a few days and then it lays fallow for weeks. But I do keep notes for my role-playing games with great discipline. I keep my prep in little notebooks.

The prep notebooks are mostly chronological, but then there are two or three pages of notes on a particular adventure, I tape some printout onto a page, I draw a map... you have seen examples before: 2019-10-06 How to Prep, 2019-01-31 Game Prep, 2015-11-15 Prep, 2014-10-15 Adventure Prep, and so on.

printouts stuck in a notebook

I mean, I do write session reports Campaign Wiki for players after the game, but when I’m not writing about something I know, like the game that we had a few days ago, then I can’t just sit down and write. I need to jot down an idea here and there, I need to spend time doodling maps and pictures in order to give my brain opportunities for new ideas. They take time to develop and I can’t get up and simply do something else. Doodling is my way of staying focused on the topic.

Somehow that doesn’t work with a wiki. Perhaps if I had a larger wiki, separate from the one for my players, where I wouldn’t feel bad writing just two or three sentences for each idea that strikes me? It might work. But right now my problem is that it isn’t easy to doodle on my phone or at the laptop. Pen and paper still are the best medium for that.

Tags:

Add Comment

2019-11-30 Threema

I got myself a new iPhone 11, backed up my old iPhone 6S, and restored that backup onto the new phone. That took maybe three minutes. I also upgraded the new phone to the latest edition of the operating system, that took a few minutes more. Then I started Threema, which had somehow forgotten all about me.

Uh, what?

OK, it did find a backup of my ID, which is at least something, but also my contact list was empty. Why isn’t my contact list not part of the backup? I was able to regain access to my ID, which is great, but I can’t send messages to anybody, don’t know where my groups are, and I probably lost all the “trust” settings – those green dots I get for contacts for photographing their ID.

This makes me sad.

In addition to that, your group info is lost. When such a group is synchronized by the admin (and you are not the admin), or when somebody else sends a message to the group, you see them all again. But if somebody else sends a message to a group you are an admin in, you are immediately kicked out of the group and it is now abandoned: no admin. 🤔

The solution is to ask a group member to clone the group (making them the admin) and add your account back in, even though it is “the same account” as you used the ID export to regain access to your old ID. It’s weird. The solution is to use the Threema Safe and upload supposedly encrypted info to their server (not sure how you would set up your own server even though that appears to be a possibility).

I guess I didn’t follow the instructions carefully enough when I did my ID export:

Create an ID export on your previous device: Tap on “My ID”, then select “ID export”, and activate the option “Include in phone backup” after exporting your ID. Make sure to store this password in a safe place; without it, you won’t be able to restore the exported ID. [1]

And thus I didn’t see get to see this option as I used Threema again on the new phone:

When starting Threema for the first time, tap on “Restore from Backup”, select “Keep local data”, and tap “ID Export”. The ID-export string is prepopulated. What’s left to do for you is to enter the ID export’s password and to confirm by tapping “Done”. [2]

Oh well. 😐

Tags:

Comments on 2019-11-30 Threema

Crap.

That is not good - also, the more secure, the harder is to obbey things.

You already wiped your old phone?

Peter Kotrčka 2019-12-06 06:18 UTC


Yes I have. It turned out not to be too big of a problem. My wife was also in nearly all the groups I was admin of and was able to clone them (making her the admin of the new group) and add me back. So now I lost admin status in a few groups and lost all the “trust” marks of my contacts, but other than that I’m back. 😅

– Alex Schroeder 2019-12-06 08:09 UTC

Add Comment

2019-11-30 Computer History

I really need to sit down one day and look back at the history of computing. I half remember a YouTube video ironically taking the ideas of Doug Engelbart and describing an alternative future where all these things had come true and more, and as a viewer you realized that so little had come true, so little advances had been made. I need to find that video again.

Today I read chapter 9 in Tools For Thought by Howard Rheingold, The Loneliness of a Long-Distance Thinker, about Doug Engelbart. Fascinating.

Tags:

Comments on 2019-11-30 Computer History

I’m re-reading the Humane Interface by Jeff Raskin, and weeping quietly.

deshipu 2019-11-30 12:33 UTC


Haha, that was a good book. Where’s my Leap Key, and where’s my Zooming Interface!?

– Alex Schroeder 2019-11-30 15:53 UTC

Add Comment

More...

Comments


Please make sure you contribute only your own work, or work licensed under the GNU Free Documentation License. Note: in order to facilitate peer review and fight vandalism, we will store your IP number for a number of days. See Privacy Policy for more information. See Info for text formatting rules. You can edit this page if you need to fix typos. You can subscribe to updates by email without leaving a comment.

To save this page you must answer this question:

Please say HELLO.

Referrers: Alex Schroeder Backup Blog Take on Rules Diary Diary