Keeping one's fleeting notes separate from their permanent notes can be useful for managing the idea of clutter.

Luhmann generally did this by keeping things in different boxes. Modern academics may use different digital applications (Zotero/Obsidian, Hypothes.is/Zettlr, etc.as examples) for each as long as there is some reasonable dovetail between the two for data transfer when necessary.

Most veteran note takers will advise against importing old notes into a new digital space for the extra amount of administrative overhead and refactoring it can create.

Often old notes may be: - well assimilated into your memory already - poorly sourced or require lots of work and refactoring to use or reuse them - become a time suck trying to make them "perfect"

Better advice is potentially pull them into your system in a different spot so they're searchable and potentially linkable/usable as you need them. If this seems like excessive work, and it very well may be, then just pull in individual notes as you need or remember them.

With any luck the old notes are easily searchable/findable in whichever old system they happen to be in, so they're still accessible.

I'll note here the conflicting definitions of multiple storage in my tags to mean: - storing a single note under multiple subject headings or index terms - storing notes in various different (uncentralized locations), so having multiple different zettelkasten at home/office, storing some notes in social media locations, in various notebooks, etc. This means you have to search across multiple different interfaces to find the thing you're looking at.

I should create a new term to distinguish these two, but for now they're reasonably different within their own contexts that it's not a big problem unless one or the other scales.

Related here is the horcrux problem of note taking or even social media. The mental friction of where did I put that thing? As a result, it's best to put it all in one place.

How can you build on a single foundation if you're in multiple locations? The primary (only?) benefit of multiple locations is redundancy in case of loss.

Ryan Holiday and Robert Greene are counter examples, though Greene's books are distinct projects generally while Holiday's work has a lot of overlap.

Should You Have One Zettelkasten or Many?<br /> by Christian Tietze

Within the history of personal knowledge management, one was often faced with where to store their notes so that it would be easy to find and use them again. Often this was done using slip methods by means of "multiple storage" by making multiple copies and filing them under various headings. This copying process was onerous and breaks the modern database principle "don't repeat yourself" (DRY).

Alternate means of doing this include storing it in one place and then linking that location to multiple subject headings in an index, though this may cause issues of remembering which subject heading when there are many appropriate potential synonyms.

Modern digital methods allow one to store a note in one location and refer to it in multiple ways electronically as well as with aliases.

https://www.reddit.com/r/antinet/comments/10xls6m/does_anyone_ever_get_frustrated/

Categorizing ideas (and or indexing them for search) can be useful for quick bulk storage, but the additional work of linking ideas to each other with in a Luhmann-esque zettelkasten can be more useful in the long term in developing ideas.

Storage by category means that ideas aren't immediately developed explicitly, but it means that that work is pushed until some later time at which the connections must be made to turn them into longer works (articles, papers, essays, books, etc.)

Aquathermie Rekentool

Energy Storage Cost and Performance Database. U.S. Department of Energy

How can we better thing of card indexes as positive feedback mechanisms? Will describes it as the "Great Wheel of Positive Feedback" which reminds me a bit of flywheels for storing energy for later use.

https://www.target.com/p/6qt-clear-storage-box-white-room-essentials-8482/-/A-80162146

6qt Clear Storage Box White - Room Essentials™<br /> Outside Dimensions: 13 1/2" x 8 1/8" x 4 5/8"<br /> Interior Dimensions at bottom: 11 1/2" x 6 3/8" x 4 3/8"<br /> Ideal for a variety of basic and lightweight storage needs, for use throughout the home<br /> Opaque lid snaps firmly onto the base and provides a grip for easy lifting<br /> Clear base allows contents to easily be viewed and located<br /> Indexed lids allow same size storage boxes to neatly stack upon each other<br /> BPA-free and phthalate-free<br /> Proudly made in the USA

Specifications<br /> Closure Type: Snap<br /> Used For: Organizing<br /> Capacity (Volume): 6 Quart<br /> Features: Portable, Lidded, Nesting, Stackable<br /> Assembly Details: No Assembly Required<br /> Primary item stored: Universal Storage<br /> Material: Plastic<br /> Care & Cleaning: Spot or Wipe Clean<br /> TCIN: 80162146<br /> UPC: 073149215284<br /> Item Number (DPCI): 002-02-9534<br /> Origin: Made in the USA<br /> Description<br /> Organize, sort and contain! The Room Essentials 6 Quart Storage Box is ideal for a variety of basic and lightweight household storage needs, helping to keep your living spaces neat. The clear base allows contents to be easily identified at a glance, while the opaque lid snaps firmly onto the base to keep contents contained and secure. Stack same size containers on top of each other for efficient use of vertical storage space. When storing items away, use good judgment and don’t overload them or stack them too high; be mindful of the weight in each box and place the heaviest box on the bottom. This storage box is ideal for sorting and storing shoes, accessories, crafts and other small items around the home and fits conveniently on 16" wire closet shelving, bringing order to closets. The overall assembled dimensions of this item are 13 1/2" L x 8 1/8" W x 4 5/8" H.

Examples of this and similar products in use as a box for zettelkasten: - https://photos.google.com/share/AF1QipN5GmVoIhCwma1czj27bXlVDKIUfbOU3a91dYuPBNZaGsEhcZYllmotxup6OxUHhA?pli=1&key=RlhXMTM0WUpuQ2hlQkdDNzA0S1BmNzVQblo4Ti1n - https://imgur.com/a/rW8TZKt

How is learning defined by Sweller in 2002? (Metiri Group, Cisco Sytems, 2008) The storage of automated schema in long-term memory

What term does Sweller define as the "storage of automated schema in long-term memory"?

Deutsch used flimsy copy paper, much like Niklas Luhmann, and as a result some are on the verge of disintegration through use over time.

The wear of the paper here, however, is indicative of active use over time as well as potential care in use, a useful historical fact.

!- for : global capacity renewable energy storage - this is not realistic

https://www.ebay.com/itm/115477031627?hash=item1ae2f7aacb:g:yUIAAOSwQp1ix3zT

Another example of someone using a library card catalog as wine storage

Someone was apparently using an old library card catalog to store wine bottles!

https://en.wikipedia.org/wiki/Paper_data_storage

https://en.wikipedia.org/wiki/Punched_card

Link to Beatrice Webb's use of note taking methods as a means of data storage, search, and sort in the early 1900s.

```js function formatBytes(bytes, decimals = 2) { if (bytes === 0) return '0 Bytes';

const k = 1024; const dm = decimals < 0 ? 0 : decimals; const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']; const i = Math.floor(Math.log(bytes) / Math.log(k)); return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i]; } ```

A card index can be a massive boon to a writer as a well-indexed one, in particular, will save massive amounts of time which might otherwise be spent searching for quotes or ideas that they know they know, but can't easily recreate.

Regardless of what sort of physical instantiation one's notes may take, a workable storage option for them is necessary whether it is a simple box, a shelving system, a curiosity cabinet, a flat file, or even an entire room itself.

The public Indyweb is eminently designed as a public space for holding deep, continuous, asynchronous conversations with provenance. That is, if the partcipant consents to public conversation, ideas can be publicly tracked. Whoever reads your public ideas can be traced.and this paper trail is immutably stored, allowing anyone to see the evolution of ideas in real time.

In theory, this does away with the need for patents and copyrights, as all ideas are traceable to the contributors and each contribution is also known. This allows for the system to embed crowdsourced microfunding, supporting the best (upvoted) ideas to surface.

Participants in the public Indyweb ecosystem are called Indyviduals and each has their own private data hub called an Indyhub. Since Indyweb is interpersonal computing, each person is the center of their indyweb universe. Through the discoverability built into the Indyweb, anything of immediate salience is surfaced to your private hub. No applications can use your data unless you give exact permission on which data to use and how it shall be used. Each user sets the condition for their data usage. Instead of a user's data stored in silos of servers all over the web as is current practice, any data you generate, in conversation, media or data files is immediately accessible on your own Indyhub.

Indyweb supports symmathesy, the exchange of ideas based on an appropriate epistemological model that reflects how human INTERbeings learn as a dynamic interplay between individual and collective learning. Furthermore, all data that participants choose to share is immutably stored on content addressable web3 storage forever. It is not concentrated on any server but the data is stored on the entire IPFS network:

"IPFS works through content adddressibility. It is a peer-to-peer (p2p) storage network. Content is accessible through peers located anywhere in the world, that might relay information, store it, or do both. IPFS knows how to find what you ask for using its content address rather than its location.

There are three fundamental principles to understanding IPFS:

Unique identification via content addressing Content linking via directed acyclic graphs (DAGs) Content discovery via distributed hash tables (DHTs)" (Source: https://docs.ipfs.io/concepts/how-ipfs-works/)

The privacy, scalability, discoverability, public immutability and provenance of the public Indyweb makes it ideal for supporting hyperconversations that emerge tomorrows collectively emergent solutions. It is based on the principles of thought augmentation developed by computer industry pioneers such as Doug Englebart and Ted Nelson who many decades earlier in their prescience foresaw the need for computing tools to augment thought and provide the ability to form Network Improvement Communities (NIC) to solve a new generation of complex human challenges.

While he's couching it in the computer science milieu of his day, this is not dissimilar to the Llullan combinatorial arts.

It's true that each note taking application may be purpose fit for a particular use, but having a single store for all of your notes is incredibly important for future search and re-discovery. Keeping one's notes across a range of applications is disaster waiting to happen, at least until there is a bigger aggregate search function that can search across multiple platforms.

Like pumped hydro with rocks

Guarascio, F. (2022, January 14). Poorer nations reject over 100 mln COVID-19 vaccine doses as many near expiry. Reuters. https://www.reuters.com/business/healthcare-pharmaceuticals/more-than-100-million-covid-19-vaccines-rejected-by-poorer-nations-dec-unicef-2022-01-13/

Edge Computing: What It Is and Why It Matters0 https://en.itpedia.nl/2021/12/29/edge-computing-what-it-is-and-why-it-matters/ Edge computing is an emerging new trend in cloud data storage that improves how we access and process data online. Businesses dealing with high-frequency transactions like banks, social media companies, and online gaming operators may benefit from edge computing.

Curiously, and possibly coincidently, the idea of the index card and the invention of the house number co-occur in the same decade and the same town. This creates the potential of abstracting the representation of information and people into numbers for easier access and linking.

The sorting function is also done by mental links from one space to another similar to the method of loci in Western culture. cross reference the idea of songlines

pyrus scroll and the sheet of parchment.

Which others is she missing from a mnemonics perspective? I'm impressed that she indicates the khipu, but there are certainly other indigenous methods from oral cultures.

So, it seems to add a layer of indirection, so instead of everyone needing to read off the same bits of a disk, the data is stored in places indexed by the KV store, which allows reads and writes to be spread across a linearly scaling storage layer.

Worth reading the paper to check if this guess is close to reality

Incredible. I may have destroyed my current batch. I'll have to start over. Good thing I only made a moderate amount.

Welcome to Connect Warehouse Storage Solutions. We are experts in providing professional storage services, including eCommerce warehouse storage solutions, pallet storage, container de-stuffing, and more.

We pride ourselves on delivering safe, secure, and cost-effective eCommerce warehouse storage and industrial storage solutions, and have been doing so for customers around the world for many years. Our expert team of staff is well trained and experienced, and our facility is state of the art.

All in all, we are confident that we understand the complexities of warehouse storage better than anyone, making us your ideal industrial storage solutions partner.

Our Warehouse Commercial Storage Solutions Facility

When you choose Connect, you’re choosing versatility, modernity, and efficiency for your storage requirements. Our brilliant facility features heavy-duty racking, highly trained staff, advanced technology, and onsite security to make sure that all of your goods are safe and sound in a professional environment.

All of this is set up to help ensure maximum safety for your inventory and more control for you, so you have peace of mind every step of the way that your goods are in safe hands.

Within our facility, we provide an eclectic mix of different industrial storage provisions, with something to suit every requirement. Let’s take a look at some of the different kinds of provisions we handle at Connect and see how we can help you with all of your storage needs today.

industrial storage solutions uk

Pallet Storage with Connect Welcome to Connect Pallet Storage. Here at Connect, we provide the best of the best when it comes to pallet storage and have been doing so for national and international customers for a number of years.

​We’ve built up a strong reputation over the years for our attention to detail and beautifully kept, high-quality pallet storage warehouse facility. And it is here where we can help your business thrive, no matter what it is you do or what it is you require when it comes to pallet storage.

Racked Pallet Storage Our pallet storage warehouse features high-quality, durable racked storage for your pallet storage requirements.

We have over 4,500 pallet spaces available in our fully racked warehouse and provide a safe and secure space for your cargo.

pallet storage warehouse

How is it not so surprising that Carl Linnaeus, the creator of a huge taxonomic system, also came up with the idea for index cards in 1760.

How does this fit into the history of the commonplace book and information management? Relationship to the idea of a zettelkasten?

Currently, I am using SharedPreference which is still alright to use. However, there is a better option called DataStore. This allows data to be stored asynchronously.

RESEARCH MORE. What is this? What it's role in memory storage?

I have heard this from several of my sources. This one is a bit more dated than some of the others I've used, so I need to look at something more recent and see if this has changed.

Size: 1.3m x 2m

Bush emphasises the importance of retrieval in the storage of information. He talks about technical limitations, but in this paragraph he stresses that retrieval is made more difficult by the "artificiality of systems of indexing", in other words, our default file-cabinet metaphor for storing information.

Information in such a hierarchical architecture is found by descending down into the hierarchy, and back up again. Moreover, the information we're looking for can only be in one place at a time (unless we introduce duplicates).

Having found our item of interest, we need to ascend back up the hierarchy to make our next descent.

Retrieval is the key activity we're interested in. Storage only matters in as much as we can retrieve effectively. At the time of writing (1945) large amounts of information could be stored (extend the record), but consulting that record was still difficult.

That is, to request token if the app is not running in the Azure cloud with a managed identity:

• Acquire a token from Azure AD for authorizing requests from a client application

• Request an access token in Azure Active Directory B2C (and the other chapters in the Authorization protocols section)

If a tool benefits the entire team, vs. just the designer, it becomes an easier purchase decision.

Supporting Open Science Data Curation, Preservation, and Access by Libraries. (2020, June 25). https://www.youtube.com/watch?v=SbmGWHpzAHs&feature=youtu.be

s3 perfomance use columnar formats

when snowball

1000Mbps 12 days 60TB

Destul de puțin...

Practical highlights in my opinion:

• It's important to know about data padding in PG.
• Be conscious when modelling data tables about columns ordering, but don't be pure-school and do it in a best-effort basis.
• Gains up to 25% in wasted storage are impressive but always keep in mind the scope of the system. For me, gains are not worth it in the short-term. Whenever a system grows, it is possible to migrate data to more storage-efficient tables but mind the operative burder.

Here follows my own commands on trying the article points. I added - pg_column_size(row()) on each projection to have clear absolute sizes.

-- How does row function work?

SELECT pg_column_size(row()) AS empty,
       pg_column_size(row(0::SMALLINT)) AS byte2,
       pg_column_size(row(0::BIGINT)) AS byte8,
       pg_column_size(row(0::SMALLINT, 0::BIGINT)) AS byte16,
       pg_column_size(row(''::TEXT)) AS text0,
       pg_column_size(row('hola'::TEXT)) AS text4,
       0 AS term
;

-- My own take on that

SELECT pg_column_size(row()) AS empty,
       pg_column_size(row(uuid_generate_v4())) AS uuid_type,
       pg_column_size(row('hola mundo'::TEXT)) AS text_type,
       pg_column_size(row(uuid_generate_v4(), 'hola mundo'::TEXT)) AS uuid_text_type,
       pg_column_size(row('hola mundo'::TEXT, uuid_generate_v4())) AS text_uuid_type,
       0 AS term
;

CREATE TABLE user_order (
  is_shipped    BOOLEAN NOT NULL DEFAULT false,
  user_id       BIGINT NOT NULL,
  order_total   NUMERIC NOT NULL,
  order_dt      TIMESTAMPTZ NOT NULL,
  order_type    SMALLINT NOT NULL,
  ship_dt       TIMESTAMPTZ,
  item_ct       INT NOT NULL,
  ship_cost     NUMERIC,
  receive_dt    TIMESTAMPTZ,
  tracking_cd   TEXT,
  id            BIGSERIAL PRIMARY KEY NOT NULL
);

SELECT a.attname, t.typname, t.typalign, t.typlen
  FROM pg_class c
  JOIN pg_attribute a ON (a.attrelid = c.oid)
  JOIN pg_type t ON (t.oid = a.atttypid)
 WHERE c.relname = 'user_order'
   AND a.attnum >= 0
 ORDER BY a.attnum;

-- What is it about pg_class, pg_attribute and pg_type tables? For future investigation.

-- SELECT sum(t.typlen)
-- SELECT t.typlen
SELECT a.attname, t.typname, t.typalign, t.typlen
  FROM pg_class c
  JOIN pg_attribute a ON (a.attrelid = c.oid)
  JOIN pg_type t ON (t.oid = a.atttypid)
 WHERE c.relname = 'user_order'
   AND a.attnum >= 0
 ORDER BY a.attnum
;

-- Whoa! I need to master mocking data directly into db.

INSERT INTO user_order (
    is_shipped, user_id, order_total, order_dt, order_type,
    ship_dt, item_ct, ship_cost, receive_dt, tracking_cd
)
SELECT true, 1000, 500.00, now() - INTERVAL '7 days',
       3, now() - INTERVAL '5 days', 10, 4.99,
       now() - INTERVAL '3 days', 'X5901324123479RROIENSTBKCV4'
  FROM generate_series(1, 1000000);

-- New item to learn, pg_relation_size. 

SELECT pg_relation_size('user_order') AS size_bytes,
       pg_size_pretty(pg_relation_size('user_order')) AS size_pretty;

SELECT * FROM user_order LIMIT 1;

SELECT pg_column_size(row(0::NUMERIC)) - pg_column_size(row()) AS zero_num,
       pg_column_size(row(1::NUMERIC)) - pg_column_size(row()) AS one_num,
       pg_column_size(row(9.9::NUMERIC)) - pg_column_size(row()) AS nine_point_nine_num,
       pg_column_size(row(1::INT2)) - pg_column_size(row()) AS int2,
       pg_column_size(row(1::INT4)) - pg_column_size(row()) AS int4,
       pg_column_size(row(1::INT2, 1::NUMERIC)) - pg_column_size(row()) AS int2_one_num,
       pg_column_size(row(1::INT4, 1::NUMERIC)) - pg_column_size(row()) AS int4_one_num,
       pg_column_size(row(1::NUMERIC, 1::INT4)) - pg_column_size(row()) AS one_num_int4,
       0 AS term
;

SELECT pg_column_size(row(''::TEXT)) - pg_column_size(row()) AS empty_text,
       pg_column_size(row('a'::TEXT)) - pg_column_size(row()) AS len1_text,
       pg_column_size(row('abcd'::TEXT)) - pg_column_size(row()) AS len4_text,
       pg_column_size(row('abcde'::TEXT)) - pg_column_size(row()) AS len5_text,
       pg_column_size(row('abcdefgh'::TEXT)) - pg_column_size(row()) AS len8_text,
       pg_column_size(row('abcdefghi'::TEXT)) - pg_column_size(row()) AS len9_text,
       0 AS term
;

SELECT pg_column_size(row(''::TEXT, 1::INT4)) - pg_column_size(row()) AS empty_text_int4,
       pg_column_size(row('a'::TEXT, 1::INT4)) - pg_column_size(row()) AS len1_text_int4,
       pg_column_size(row('abcd'::TEXT, 1::INT4)) - pg_column_size(row()) AS len4_text_int4,
       pg_column_size(row('abcde'::TEXT, 1::INT4)) - pg_column_size(row()) AS len5_text_int4,
       pg_column_size(row('abcdefgh'::TEXT, 1::INT4)) - pg_column_size(row()) AS len8_text_int4,
       pg_column_size(row('abcdefghi'::TEXT, 1::INT4)) - pg_column_size(row()) AS len9_text_int4,
       0 AS term
;

SELECT pg_column_size(row(1::INT4, ''::TEXT)) - pg_column_size(row()) AS int4_empty_text,
       pg_column_size(row(1::INT4, 'a'::TEXT)) - pg_column_size(row()) AS int4_len1_text,
       pg_column_size(row(1::INT4, 'abcd'::TEXT)) - pg_column_size(row()) AS int4_len4_text,
       pg_column_size(row(1::INT4, 'abcde'::TEXT)) - pg_column_size(row()) AS int4_len5_text,
       pg_column_size(row(1::INT4, 'abcdefgh'::TEXT)) - pg_column_size(row()) AS int4_len8_text,
       pg_column_size(row(1::INT4, 'abcdefghi'::TEXT)) - pg_column_size(row()) AS int4_len9_text,
       0 AS term
;

SELECT pg_column_size(row()) - pg_column_size(row()) AS empty_row,
       pg_column_size(row(''::TEXT)) - pg_column_size(row()) AS no_text,
       pg_column_size(row('a'::TEXT)) - pg_column_size(row()) AS min_text,
       pg_column_size(row(1::INT4, 'a'::TEXT)) - pg_column_size(row()) AS two_col,
       pg_column_size(row('a'::TEXT, 1::INT4)) - pg_column_size(row()) AS round4;

SELECT pg_column_size(row()) - pg_column_size(row()) AS empty_row,
       pg_column_size(row(1::SMALLINT)) - pg_column_size(row()) AS int2,
       pg_column_size(row(1::INT)) - pg_column_size(row()) AS int4,
       pg_column_size(row(1::BIGINT)) - pg_column_size(row()) AS int8,
       pg_column_size(row(1::SMALLINT, 1::BIGINT)) - pg_column_size(row()) AS padded,
       pg_column_size(row(1::INT, 1::INT, 1::BIGINT)) - pg_column_size(row()) AS not_padded;

SELECT a.attname, t.typname, t.typalign, t.typlen
  FROM pg_class c
  JOIN pg_attribute a ON (a.attrelid = c.oid)
  JOIN pg_type t ON (t.oid = a.atttypid)
 WHERE c.relname = 'user_order'
   AND a.attnum >= 0
 ORDER BY t.typlen DESC;

DROP TABLE user_order;

CREATE TABLE user_order (
  id            BIGSERIAL PRIMARY KEY NOT NULL,
  user_id       BIGINT NOT NULL,
  order_dt      TIMESTAMPTZ NOT NULL,
  ship_dt       TIMESTAMPTZ,
  receive_dt    TIMESTAMPTZ,
  item_ct       INT NOT NULL,
  order_type    SMALLINT NOT NULL,
  is_shipped    BOOLEAN NOT NULL DEFAULT false,
  order_total   NUMERIC NOT NULL,
  ship_cost     NUMERIC,
  tracking_cd   TEXT
);

-- And, what about other varying size types as JSONB?

SELECT pg_column_size(row('{}'::JSONB)) - pg_column_size(row()) AS empty_jsonb,
       pg_column_size(row('{}'::JSONB, 0::INT4)) - pg_column_size(row()) AS empty_jsonb_int4,
       pg_column_size(row(0::INT4, '{}'::JSONB)) - pg_column_size(row()) AS int4_empty_jsonb,
       pg_column_size(row('{"a": 1}'::JSONB)) - pg_column_size(row()) AS basic_jsonb,
       pg_column_size(row('{"a": 1}'::JSONB, 0::INT4)) - pg_column_size(row()) AS basic_jsonb_int4,
       pg_column_size(row(0::INT4, '{"a": 1}'::JSONB)) - pg_column_size(row()) AS int4_basic_jsonb,
       0 AS term;

The NSA must be psyched about this.

How is information, for example, a conversation accounted for in this model? As we go forward and find more efficient ways to store and convey information in fewer 1s and 0s, must we constantly reevaluate this relationship? Passive vs Active storage of information seems to be key here as well.

this is the storage question everyone always goes to 1st when we use the word "data" in libraries. Is there possibly another question we should ask first?

Is access private/public?

This point seems to be in direct contradiction to the claim above that "Indexes (primary and secondary) are always stored in DRAM for fast access and are never stored on Solid State Drives (SSDs) to ensure low wear."

Does this really mean to suggest that Aerospike bypasses the linux block device layer? Is there a kernel driver? Does this mean I can't use any filesystem I want and know how to administrate? Is the claim that the "linux file system" (which I take to mean, I guess, the virtual file system layer) "built for rotation drives" even accurate? We've had ram disks for a long, long time. And before that we've had log structured filesystems, too, and even devices that aren't random access like tape drives. Seems like dubious claims all around.