Design tokens are platform-agnostic and are the first layer of design decisions in a design system.

Counterpoint: the judicious use of abstraction is/can be, in some instances, the solution to giving users agency and reconfigurability.

Software that has to be torn down is the result of software built upon bad abstractions. Abstractions are not ipso fact bad. They just need to be chosen on the criteria of whether or not they solve a problem.

That's unfortunate. Can't use auto-submit form to protect from such behavior then.

仅仅只是做个标记

That is strange. You need to periodically pop online to renew credentials or you're kicked out.

https://indieweb.org/User:Boffosocko.com#Backlinks

https://github.com/terrychenzw/obsidian-zettelkasten-navigation

“User” as a component of the bigger system

Thinking about this and any contrast between “user experience design” and “human computer interaction”. And about schema.org constructs embedded in web pages…creating web pages that were meant to be read by both humans and bots.

Don't rush languages, it really infuriates people if you do that.

reviews overall are in the 'meh' section. I don't want this to happen. But the application responds and is attempting to assist.

While the idea of a common user interface on computers may have felt like a selling point when facing a new scary machine with a variety of functionalities, did it really save that much time, effort, and learning curve? Particularly with respect to the common office tools it was replacing?

The common user interface was really more a benefit to the company and all the companies which programmed for it at scale. The benefits are like Melvil Dewey's standardization of the Dewey Decimal Classification which allowed libraries everywhere to work on the same system rather than needing to reinvent their own individually.

This sort of innovation with scalability is helpful as humans are far better at imitation than innovation.

Introducing a network for thoughtful conversations by [[Jatan Mehta]]

Feedback and how important it is.

This comment is close, but it's also about control.

https://lu.ma/toolsforthought

Certainly! Let's break down the provided code snippets:

1. What is it and why is it used?

In Mongoose, a schema is a blueprint for defining the structure of documents within a collection. When you define a schema, you can also attach methods to it. These methods become instance methods, meaning they are available on the individual documents (instances) created from that schema.

Instance methods are useful for encapsulating functionality related to a specific document or model instance. They allow you to define custom behavior that can be executed on a specific document. In the given example, the findSimilarTypes method is added to instances of the Animal model, making it easy to find other animals of the same type.

2. Syntax:

Using methods object directly in the schema options:

javascript const animalSchema = new Schema( { name: String, type: String }, { methods: { findSimilarTypes(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); } } } );

Using methods object directly in the schema:

javascript animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

Using Schema.method() helper:

javascript animalSchema.method('findSimilarTypes', function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); });

3. Explanation in Simple Words with Examples:

Why it's Used:

Imagine you have a collection of animals in your database, and you want to find other animals of the same type. Instead of writing the same logic repeatedly, you can define a method that can be called on each animal instance to find similar types. This helps in keeping your code DRY (Don't Repeat Yourself) and makes it easier to maintain.

Example:

```javascript const mongoose = require('mongoose'); const { Schema } = mongoose;

// Define a schema with a custom instance method const animalSchema = new Schema({ name: String, type: String });

// Add a custom instance method to find similar types animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

// Create the Animal model using the schema const Animal = mongoose.model('Animal', animalSchema);

// Create an instance of Animal const dog = new Animal({ type: 'dog', name: 'Buddy' });

// Use the custom method to find similar types dog.findSimilarTypes((err, similarAnimals) => { console.log(similarAnimals); }); ```

In this example, findSimilarTypes is a custom instance method added to the Animal schema. When you create an instance of the Animal model (e.g., a dog), you can then call findSimilarTypes on that instance to find other animals with the same type. The method uses the this.type property, which refers to the type of the current animal instance. This allows you to easily reuse the logic for finding similar types across different instances of the Animal model.

Looking at the screen captures, one thing I like about HIEW is that it groups octets into sets of 32 bits in the hex view (by interspersing hyphens (-) throughout). Nice.

I've noticed that sometime in December 2023, Hypothes.is has updated their public software to include the page number of the pdf annotations are made in into their user interface.

https://veronicaerb.com/

// oftentimes once we have a proper e2e test around logging in
// there is NO more reason to actually use our UI to log in users
// doing so wastes a huge amount of time, as our entire page has to load
// all associated resources have to load, we have to wait to fill the
// form and for the form submission and redirection process

// Not recommended: log into the application like a user // by typing into the form and clicking Submit // While this works, it is slow and exercises the login form // and NOT the feature you are trying to test.

first sighting: https://datatracker.ietf.org/doc/html/draft-ietf-scim-core-schema-22#section-4.1.1

https://www.johnpe.art/2023/10/31/making-webmentions-look-more-conversational/

https://www.coreycarvalho.com/

posted reply:

I appreciate that you're centering some of the Cornell notes workflow into a linked note taking system. I don't think many (any?) of the note taking platforms have made it easy for students to quickly or easily create questions from their Cornell notes and build them into a spaced repetition practice. I've seen a handful transfer their work into other platforms like Anki, Mnemosyne, etc. for this purpose, but it would be interesting to see Protolyst and others offer this as out of the box functionality for following up on Cornell notes workflows. I've not seen it mentioned in any parts of the note taking space, but Cornell notes are essentially a Bibliography note/card (where the source is typically a lecture) + fleeting notes which stem from it (in a Niklas Luhmann-artig zettelkasten framing) out of which one would build their permanent notes as well as create questions for spaced repetition and review. User interfaces like that of Protolyst could potentially leverage these common workflows to great advantage.

Next Step for your Cornell Notes? by Dr Maddy<br /> https://www.youtube.com/watch?v=QZFrR-u9Ovk

Like that someone in the space is thinking about taking Cornell notes and placing them into the linked note taking framing.

She doesn't focus enough on the questions or the spaced repetitions pieces within Cornell. How might this be better built into a UI like Protolyst, Obsidian, etc.? Where is this in people's note taking workflows?

SIMPLER First Zettelkasten from Scratch by Dr Maddy https://www.youtube.com/watch?v=TRrKO6TNN6w

Protolyst has an "atom" functionality for short quick notes.

The UI of Protolyst looks nice, but I wonder how well it holds up when one is at 10,000 notes? Is it still as simple?

reply to u/Sensitive-Binding at https://www.reddit.com/r/antinet/comments/17ck5la/what_is_it_with_index_cards/

Some of it may involve the difference in available space versus other forms of writing on larger pages of paper. Similarly, many find that there is less pressure to write something short on Twitter or similar social media platforms because there is less space in the user interface that your mind feels the need to fill up. One can become paralyzed by looking at the larger open space on a platform like WordPress with the need to feel like they should write more.

With index cards you fill one up easily enough, and if there's more, you just grab another card and repeat.

cross reference with Fermat's Last Theorem being easier to suggest in a margin than actually writing it out in full.

Great definition of "agency." I think though that it leaves it up to us to determine what meaningful action is and what constitutes satisfying results.

I've not tried it myself or seen an example, but given the structure, it would seem like Reveal.js might give you the the sort of functionality you're looking for while having many other affordances one might look for in a digital and/or online zettelkasten.

inspired by question by u/Plastic-Lettuce-7150 at https://www.reddit.com/r/Zettelkasten/comments/168cmca/which_note_taking_app_for_a_luhmann_zettlekasten/

```js // Log the full user-agent data navigator .userAgentData.getHighEntropyValues( ["architecture", "model", "bitness", "platformVersion", "fullVersionList"]) .then(ua => { console.log(ua) });

// output { "architecture":"x86", "bitness":"64", "brands":[ { "brand":" Not A;Brand", "version":"99" }, { "brand":"Chromium", "version":"98" }, { "brand":"Google Chrome", "version":"98" } ], "fullVersionList":[ { "brand":" Not A;Brand", "version":"99.0.0.0" }, { "brand":"Chromium", "version":"98.0.4738.0" }, { "brand":"Google Chrome", "version":"98.0.4738.0" } ], "mobile":false, "model":"", "platformVersion":"12.0.1" } ```

```idl dictionary NavigatorUABrandVersion { DOMString brand; DOMString version; };

dictionary UADataValues { DOMString architecture; DOMString bitness; sequence<NavigatorUABrandVersion> brands; DOMString formFactor; sequence<NavigatorUABrandVersion> fullVersionList; DOMString model; boolean mobile; DOMString platform; DOMString platformVersion; DOMString uaFullVersion; // deprecated in favor of fullVersionList boolean wow64; };

dictionary UALowEntropyJSON { sequence<NavigatorUABrandVersion> brands; boolean mobile; DOMString platform; };

[Exposed=(Window,Worker)] interface NavigatorUAData { readonly attribute FrozenArray<NavigatorUABrandVersion> brands; readonly attribute boolean mobile; readonly attribute DOMString platform; Promise<UADataValues> getHighEntropyValues (sequence<DOMString> hints ); UALowEntropyJSON toJSON (); };

interface mixin NavigatorUA { [SecureContext] readonly attribute NavigatorUAData userAgentData ; };

Navigator includes NavigatorUA; WorkerNavigator includes NavigatorUA; ```

https://erinflotodesigns.com/collections/metal-stencils/products/bullet-journal-monthly-circle-tracker-stencil-habit-tracker-stencil-unique-design-stencil-cleaning-tracker-stencil

Erin Floto has a metal stencil for a chronodex circular design for use in bullet journals. It's a form of circular calendar with the inner circle containing space for daily, bi-weekly, weekly, monthly and longer time horizons with succeeding rings of the circle containing space for data related to the inner categories. Some of the exterior rings also include numbered squares representing days of the month or week on which a task should be done or for which a habit on an interior part of the circle might be tracked.

The chronodex, a portmanteau of chrono (time) and index, idea is fairly simple, but can be quite complex. For actual use, one may need to be able to spin the visualization around to read and understand it.

Other stencils with habit trackers, etc: https://erinflotodesigns.com/collections/metal-stencils

Have in mind the genres tested.

Looking from a perspective of "how might we use such tools in UX" we're better served by looking at documents that UX generates through the lens of identifying parallels to the study's findings for business documents.

To use AI to generate drafts, we'll want to look at AI tools built into design tools UXers use to create drafts. Those tools are under development but still developing.

Tagging and linking with AI (Napkin.one) by Nicole van der Hoeven

https://www.youtube.com/watch?v=p2E3gRXiLYY

Nicole underlines the value of a good user interface for traversing one's notes. She'd had issues with tagging things in Obsidian using their #tag functionality, but never with their [[WikiLink]] functionality. Something about the autotagging done by Napkin's artificial intelligence makes the process easier for her. Some of this may be down to how their user interface makes it easier/more intuitive as well as how it changes and presents related notes in succession.

Most interesting however is the visual presentation of notes and tags in conjunction with an outliner for taking one's notes and composing a draft using drag and drop.

Napkin as a visual layer over tooling like Obsidian, Logseq, et. al. would be a much more compelling choice for me in terms of taking my pre-existing data and doing something useful with it rather than just creating yet another digital copy of all my things (and potentially needing sync to keep them up to date).

What is Napkin doing with all of their user's data?

Circling back around to this after a mention by Tim Bushell at Dan Allosso's Book Club this morning. Nicole van der Hoeven has been using it for a while now and has several videos.

Though called Napkin, which conjures the idea of (wastebook) notes scribbled on a napkin, is a card-based UI which has both manual and AI generated tags in a constellation-like UI. It allows creating "stacks" of notes which are savable and archivable in an outline-esque form (though the outline doesn't appear collapsible) as a means of composition.

It's got a lot of web clipper tooling for saving and some dovetails for bringing in material from Readwise, but doesn't have great data export (JSON, CSV) at the moment. (Not great here means that one probably needs to do some reasonably heavy lifting to do the back and forth with other tools and may require programming skills.)

At present, it looks like just another tool in the space but could be richer with better data dovetailing with other services.

Substack slowly adding features and functionality to make them a full stack blogging/social platform... first long form, then short note features...

Also pushing in on Twitter's lunch as Twitter is having issues.

https://forum.zettelkasten.de/discussion/comment/17617#Comment_17617

There is definitely something here from a usability (and reusability) perspective when notes are broken down into smaller pieces the way that is encouraged by Hypothes.is or by writing on index cards.

Compare: - ://www.evernote.com/shard/s170/sh/d69cf793-1f14-48f4-bd48-43f41bd88678/DapavVTQh954eMRGKOVeEPHm7FxEqxBKvaKLfKWaSV1yuOmjREsMkSHvmQ - https://via.hypothes.is/https://www.otherlife.co/pkm/

The first may be most useful for a note taker who is personally trying to make sense of material, but it becomes a massive wall of text that one is unlikely to re-read or attempt to reuse at a later date. If they do attempt to reuse it at a later date, it's not clear which parts are excerpts of the original and which are the author's own words. (This page also looks like it's the sort of notes, highlighting, and underlining recommended by Tiago Forte's Building a Second Brain text using progressive summarization.)

The second set, are more concrete, more atomic, more understandable, and also as a result much more usable.

A fascinating combination of office furniture types in 1906!

The Adjustable Table Company of Grand Rapids, Michigan manufactured a combination table for both telephones and index cards. It was designed as an accessory to be stood next to one's desk to accommodate a telephone at the beginning of the telephone era and also served as storage for one's card index.

Given the broad business-based use of the card index at the time and the newness of the telephone, this piece of furniture likely was not designed as an early proto-rolodex, though it certainly could have been (and very well may have likely been) used as such in practice.

I totally want one of these as a side table for my couch/reading chair for both storing index cards and as a temporary writing surface while reading!

This could also be an early precursor to Twitter!

Folks have certainly mentioned other incarnations: - annotations in books (person to self), - postcards (person to person), - the telegraph (person to person and possibly to others by personal communication or newspaper distribution)

but this is the first version of short note user interface for both creation, storage, and distribution by means of electrical transmission (via telephone) with a bigger network (still person to person, but with potential for easy/cheap distribution to more than a single person)

One of the benefits of journaling on an index card is that the small space is much less intimidating than a large blank sheet, particularly when one isn't in the mood but feels like they ought to write. This is similar to the idea that many people find that microblogs (Twitter, Mastodon, Tumblr) are much easier to maintain than a long form blog.

Thoughts on Vulcan (Philosophy and Commentary) by Harlan (developer)

Mentioned by Jerry Michalski

Wordcraft Writers Workshop by Andy Coenen - PAIR, Daphne Ippolito - Brain Research Ann Yuan - PAIR, Sehmon Burnam - Magenta

cross reference: ChatGPT

This is, in part, why the tools for thought space should be looking at intellectual history to see how people have worked in the past.

Rather than looking at how writers have previously worked and building something specific that supports those methods, they've taken a tool designed for something else and just thrown it into the mix. Perhaps useful creativity stems from it in a new and unique way, but most likely writers are going to continue their old methods.

The interface of Wordcraft sounds like some of that interface that note takers and thinkers in the tools for thought space would appreciate in their

Rather than pairing it with artificial intelligence and prompts for specific writing tasks, one might pair tools for though interfaces with specific thinking tasks related to elaboration and continuation. Examples of these might be gleaned from lists like Project Zero's thinking routines: https://pz.harvard.edu/thinking-routines

https://whalebird.social/en/desktop/contents

Whalebird is a Mastodon, Pleroma, and Misskey client for desktop application

It's clear that gklitt is referring to the ability of extensions to augment the browser, but: * it's not clear that he has applied the same thought process to the extension itself (which is also software, after all) * the conception of in-browser content as software tooling is likely a large reason why the perspective he endorses here is not more widespread—that content is fundamentally a copy of a particular work, in the parlance of US copyright law (which isn't terribly domain-appropriate here so much as its terminology is useful)

در زمان کم بودن باطری خودمان متوقف کنیم خیلی چیزها رو ولی قبلش اطلاع بدیم به فرد ذی نفع

Can see can choose can set can enable/disable

notification push notification

Create User Stories Collaboratively With the collaboration of all the development team, the epics are broken into several smaller user stories that will be used in the sprint.

https://500ish.com/mastodon-brought-a-protocol-to-a-product-fight-ba9fda767c6a

https://www.eff.org/deeplinks/2022/12/user-generated-content-and-fediverse-legal-primer

Architecture can make UX suck.

https://borretti.me/article/unbundling-tools-for-thought

He covers much of what I observe in the zettelkasten overreach article.

Missing is any discussion of exactly what problem he's trying to solve other than perhaps, I want to solve them all and have a personal log of everything I've ever done.

Perhaps worth reviewing again to pull out specifics, but I just don't have the bandwidth today.

This is a terrible idea. At least if there's no way to opt out of it! And esp. if it doesn't auto log out the original user after some timeout.

Why? Because I may no longer remember which device/connection I used originally or may no longer have access to that device or connection.

What if that computer dies? I can't use my new computer to connect to admin UI without doing a factory reset of router?? Or I have to clone MAC address?

In my case, I originally set up via ethernet cable, but after I disconnected and connected to wifi, the same device could not log in, getting this error instead! (because different interface has different mac address)

🤗

We shape our tools and thereafter they shape us....

I came here after reading a couple articles (one on Super User & one on MS's help forums) recommending X-Mouse Button Control as a general way to disable back buttons on mice.

Note: this doesn't seem to work on Windows 11 for Microsoft USB IntelliMouse Optical.

https://fasiha.github.io/yoyogi/

Yoyogi is an alternate Mastodon reading interface that shows messages by author / thread and not as the traditional timeline.

Similar to Pinafore

why not allow user to do it directly instead of force to contact support? If they'll remove it for you because you said the user asked you to... why not just let you remove the suppression yourself? Mailgun lets you directly delete suppressions via their API.

From a gradual enrichment standpoint I understand but from a data entry standpoint this seems like more work.

Meta Pixel default behavior is to parse and send sensitive data

Wait, wait, wait... the software has a feature that scans for privately identifiable information and sends that detected info to Meta? And in other cases, the users of the Meta Pixel decided to send private information ot Meta?

I've only just noticed it now, but there is a "Verified" tab in my Twitter Notifications page to filter out notifications from verified users.

And this, in part, is just what makes social readers so valuable: a tight(er) integration of a reading and conversational interface.

https://simonwillison.net/2022/Nov/8/mastodon-is-just-blogs/

https://twitter.com/codexeditor/status/1590314248370286593

Index card and file folder influenced computer user interfaces.

https://app.sane.fyi/space/kevinmarks-gmail-com-tools-for-thought-87615

An example of the Sane user interface.

https://pinafore.social/

Pinafore is a web client for Mastodon, designed for speed and simplicity.

<small><cite class='h-cite via'>ᔥ <span class='p-author h-card'>Jessica Smith</span> in Small Web - Jayeless.net (<time class='dt-published'>07/03/2021 23:34:42</time>)</cite></small>

This is talked about in the user story book

https://readwise.io/reader/shared/01ge4efpkxh985s8eszbb9dr2e/

Simple user interface example of highlighting and annotations on an article in Readwise Reader.

https://www.denizcemonduygu.com/philo/browse/

History of Philosophy: Summarized & Visualized

This could be thought of as a form of digital, single-project zettelkasten dedicated to philosophy. It's got people, sources, and ideas which are cross linked in a Luhmann-sense (without numbering) though not in a topical index-sense. Interestingly it has not only a spatial interface and shows spatial relationships between people and ideas over time using a timeline, but it also indicates—using colored links—the ideas of disagreement/contrast/refutation and agreement/similarity/expansion.

What other (digital) tools of thought provide these sorts of visualization affordances?

Natto https://natto.dev<br /> built by Paul Shen https://twitter.com/_paulshen